21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › AT32F403A 替换 STM32F105 移植双can通讯
返回列表 发新帖我要提问

[AT32F403/403A] AT32F403A 替换 STM32F105 移植双can通讯

[复制链接]
1718|3
AuroraWaltz 发表于 2025-9-30 13:41 | 显示全部楼层 |阅读模式
移植, CAN通讯, STM32F105, F403A, AT32F4, 双CAN
硬件
        硬件方面使用的是自己画的板子，使用的AT32F403ARCT7,外设方面有USART2、USART3、CAN1、CAN2、SPI、IIC、USB、SDIO；USART接的是max485的芯片；CAN的收发芯片都是SIT1050（芯力特国产品牌，可替换tja1050）；SPI的是接了一颗W25Q128，16M的容量；IIC接的是一颗AT24C04；SDIO可插SD卡。仿真口以及串口1则使用的ATLINK的接口定义，直接使用ATLINK插上即可。USART2和USART3的485芯片，可以通过跳线帽对接起来；CAN1和CAN2也是一样。

        本测试是使用的板子上的CAN1和CAN2互发信息，所以右上角的用跳线帽把H1和H2对接，L1和L2对接。
3681968d627ba5ee31.jpg
软件


        测试使用的软件是stm32f105的3.5标准库的工程代码。由于AT32F403A的CAN2和stm32f105的CAN2是存在差异的，AT32的CAN1和CAN2是相互独立的，滤波器也是相互独立的，而f105的CAN2和CAN1有关联，所以必须修改库才能使用CAN2。

        系统时钟差异：AT32时钟配置是可以直接替换f103的，但是f103和f105的系统时钟是不一样的，所以需要配置系统时钟的和f103的一样的。
复制
  1. void RCC_Config(void)
    

  2. {
    

  3.   u8 HSEStartUpStatus = 0;
    

  4.   
    

  5.   RCC_DeInit();                     //初始化
    

  6.  
    

  7.   RCC_HSEConfig(RCC_HSE_ON);        //时能外部晶振
    

  8.  
    

  9.   HSEStartUpStatus = RCC_WaitForHSEStartUp();
    

  10.  
    

  11.   if(HSEStartUpStatus == SUCCESS)
    

  12.   {
    

  13.     RCC_PCLK2Config(RCC_HCLK_Div1);                         //APB2预分频    /* PCLK2 = HCLK 最大72Mhz*/
    

  14.  
    

  15.     RCC_PCLK1Config(RCC_HCLK_Div2);                         //APB1预分频 = 72Mhz / 2 = 36MHz    /* PCLK1 = HCLK/4 最大36MHz*/
    

  16.  
    

  17.     RCC_HCLKConfig(RCC_SYSCLK_Div1);                        //AHB预分频     /* HCLK = SYSCLK */
    

  18.  
    

  19.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);     /* PLLCLK = 8MHz * 9 = 72 MHz */
    

  20.  
    

  21.     RCC_PLLCmd(ENABLE);                                     /* Enable PLL */ 
    

  22.  
    

  23.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)      /* Wait till PLL is ready */
    

  24.     {
    

  25.     }
    

  26.  
    

  27.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);              /* Select PLL as system clock source */
    

  28.  
    

  29.     while(RCC_GetSYSCLKSource() != 0x08)                    /* Wait till PLL is used as system clock source */
    

  30.     {
    

  31.     }    
    

  32.   }
    

  33. }
中断号差异：
4629568d627e035d55.png
CAN滤波器初始化函数：
复制
  1. void CAN_FilterInit(CAN_TypeDef* CANx,CAN_FilterInitTypeDef* CAN_FilterInitStruct)    //AT32 CAN2
    

  2. {
    

  3.   uint32_t filter_number_bit_pos = 0;
    

  4.   /* Check the parameters */
    

  5.   assert_param(IS_CAN_ALL_PERIPH(CANx));
    

  6.   assert_param(IS_CAN_FILTER_NUMBER(CAN_FilterInitStruct->CAN_FilterNumber));
    

  7.   assert_param(IS_CAN_FILTER_MODE(CAN_FilterInitStruct->CAN_FilterMode));
    

  8.   assert_param(IS_CAN_FILTER_SCALE(CAN_FilterInitStruct->CAN_FilterScale));
    

  9.   assert_param(IS_CAN_FILTER_FIFO(CAN_FilterInitStruct->CAN_FilterFIFOAssignment));
    

  10.   assert_param(IS_FUNCTIONAL_STATE(CAN_FilterInitStruct->CAN_FilterActivation));
    

  11.  
    

  12.   filter_number_bit_pos = ((uint32_t)1) << CAN_FilterInitStruct->CAN_FilterNumber;
    

  13.  
    

  14.   /* Initialisation mode for the filter */
    

  15.   CANx->FMR |= FMR_FINIT;
    

  16.  
    

  17.   /* Filter Deactivation */
    

  18.   CANx->FA1R &= ~(uint32_t)filter_number_bit_pos;
    

  19.  
    

  20.   /* Filter Scale */
    

  21.   if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_16bit)
    

  22.   {
    

  23.     /* 16-bit scale for the filter */
    

  24.     CANx->FS1R &= ~(uint32_t)filter_number_bit_pos;
    

  25.  
    

  26.     /* First 16-bit identifier and First 16-bit mask */
    

  27.     /* Or First 16-bit identifier and Second 16-bit identifier */
    

  28.     CANx->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = 
    

  29.     ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow) << 16) |
    

  30.         (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow);
    

  31.  
    

  32.     /* Second 16-bit identifier and Second 16-bit mask */
    

  33.     /* Or Third 16-bit identifier and Fourth 16-bit identifier */
    

  34.     CANx->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = 
    

  35.     ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) |
    

  36.         (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh);
    

  37.   }
    

  38.  
    

  39.   if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_32bit)
    

  40.   {
    

  41.     /* 32-bit scale for the filter */
    

  42.     CANx->FS1R |= filter_number_bit_pos;
    

  43.     /* 32-bit identifier or First 32-bit identifier */
    

  44.     CANx->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = 
    

  45.     ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh) << 16) |
    

  46.         (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow);
    

  47.     /* 32-bit mask or Second 32-bit identifier */
    

  48.     CANx->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = 
    

  49.     ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) |
    

  50.         (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow);
    

  51.   }
    

  52.  
    

  53.   /* Filter Mode */
    

  54.   if (CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdMask)
    

  55.   {
    

  56.     /*Id/Mask mode for the filter*/
    

  57.     CANx->FM1R &= ~(uint32_t)filter_number_bit_pos;
    

  58.   }
    

  59.   else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */
    

  60.   {
    

  61.     /*Identifier list mode for the filter*/
    

  62.     CANx->FM1R |= (uint32_t)filter_number_bit_pos;
    

  63.   }
    

  64.  
    

  65.   /* Filter FIFO assignment */
    

  66.   if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO0)
    

  67.   {
    

  68.     /* FIFO 0 assignation for the filter */
    

  69.     CANx->FFA1R &= ~(uint32_t)filter_number_bit_pos;
    

  70.   }
    

  71.  
    

  72.   if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO1)
    

  73.   {
    

  74.     /* FIFO 1 assignation for the filter */
    

  75.     CANx->FFA1R |= (uint32_t)filter_number_bit_pos;
    

  76.   }
    

  77.   
    

  78.   /* Filter activation */
    

  79.   if (CAN_FilterInitStruct->CAN_FilterActivation == ENABLE)
    

  80.   {
    

  81.     CANx->FA1R |= filter_number_bit_pos;
    

  82.   }
    

  83.  
    

  84.   /* Leave the initialisation mode for the filter */
    

  85.   CANx->FMR &= ~FMR_FINIT;
    

  86. }
软件相关部分：


    由于CAN1的IO是使用的PB8,PB9,使用的是重映射1，软件需要配置重映射。


软件方面设定CAN的波特率是500k,使用的中断方式接收数据，接收到的帧的ID如果是我们设定的ID那就把收到的数据给打印出来,CAN1发送的帧的ID是0x11,CAN2发送的帧的ID是0x12。


相关代码如下：
复制
  1. u8 CAN1_Init(void)
    

  2. { 
    

  3.         GPIO_InitTypeDef                 GPIO_InitStructure; 
    

  4.         CAN_InitTypeDef                CAN_InitStructure;
    

  5.         CAN_FilterInitTypeDef          CAN_FilterInitStructure; 
    

  6.         NVIC_InitTypeDef                  NVIC_InitStructure;
    

  7.  
    

  8.  
    

  9.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);                //使能GPIOB时钟         
    

  10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);        
    

  11.  
    

  12.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);                //使能CAN1时钟
    

  13.  
    

  14.         GPIO_PinRemapConfig(GPIO_Remap1_CAN1,ENABLE);
    

  15.  
    

  16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    

  17.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                //复用推挽
    

  19.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                                //初始化IO
    

  20.  
    

  21.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    

  22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                                //上拉输入
    

  23.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                                //初始化IO
    

  24.  
    

  25.         //CAN单元设置
    

  26.         CAN_InitStructure.CAN_TTCM=DISABLE;                        //非时间触发通信模式  
    

  27.         CAN_InitStructure.CAN_ABOM=ENABLE;                        //软件自动离线管理         
    

  28.         CAN_InitStructure.CAN_AWUM=ENABLE;                        //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    

  29.         CAN_InitStructure.CAN_NART=DISABLE;                        //禁止报文自动传送 
    

  30.         CAN_InitStructure.CAN_RFLM=DISABLE;                         //报文不锁定,新的覆盖旧的  
    

  31.         CAN_InitStructure.CAN_TXFP=DISABLE;                        //优先级由报文标识符决定 
    

  32.         CAN_InitStructure.CAN_Mode= CAN_Mode_Normal;                //模式设置： mode:0,普通模式;1,回环模式; 
    

  33.         
    

  34.         //设置波特率  36M/((8+9+1)*4)=500Kbps
    

  35.         CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;                                //重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位  CAN_SJW_1tq         CAN_SJW_2tq CAN_SJW_3tq CAN_SJW_4tq
    

  36.         CAN_InitStructure.CAN_BS1=CAN_BS1_9tq;                         //Tbs1=tbs1+1个时间单位CAN_BS1_1tq ~CAN_BS1_16tq
    

  37.         CAN_InitStructure.CAN_BS2=CAN_BS2_8tq;                                //Tbs2=tbs2+1个时间单位CAN_BS2_1tq ~        CAN_BS2_8tq
    

  38.         CAN_InitStructure.CAN_Prescaler=4;        //分频系数(Fdiv)为brp+1        
    

  39.         CAN_Init(CAN1, &CAN_InitStructure);                //初始化CAN1 
    

  40.  
    

  41.         CAN_FilterInitStructure.CAN_FilterNumber=0;        //过滤器0
    

  42.         CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;         //屏蔽位模式
    

  43.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;         //32位宽 
    

  44.         CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;        //32位ID
    

  45.         CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    

  46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32位MASK
    

  47.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    

  48.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;//过滤器0关联到FIFO0
    

  49.         CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;//激活过滤器0
    

  50.  
    

  51.         CAN_FilterInit(CAN1,&CAN_FilterInitStructure);                        //滤波器初始化
    

  52.         
    

  53.  
    

  54.         CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);                                //FIFO0消息挂号中断允许.                    
    

  55.  
    

  56.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
    

  57.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;     // 主优先级为1
    

  58.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;            // 次优先级为0
    

  59.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  60.         NVIC_Init(&NVIC_InitStructure);
    

  61.  
    

  62.         return 0;
    

  63. } 
    

  64.  
    

  65.  
    

  66. u8 CAN2_Init()
    

  67. { 
    

  68.         GPIO_InitTypeDef                 GPIO_InitStructure; 
    

  69.         CAN_InitTypeDef                CAN_InitStructure;
    

  70.         CAN_FilterInitTypeDef          CAN_FilterInitStructure; 
    

  71.         NVIC_InitTypeDef                  NVIC_InitStructure;
    

  72.  
    

  73.  
    

  74.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//使能GPIOB时钟                                                                                                                    
    

  75.  
    

  76.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);//使能CAN2时钟        
    

  77.  
    

  78.     //CAN2 GPIO配置
    

  79.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    

  80.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;           //带上拉输入
    

  81.     GPIO_Init(GPIOB, &GPIO_InitStructure);        
    

  82.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
    

  83.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  84.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         //推挽输出
    

  85.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  86.  
    

  87.         //CAN单元设置
    

  88.         CAN_InitStructure.CAN_TTCM=DISABLE;                        //非时间触发通信模式  
    

  89.         CAN_InitStructure.CAN_ABOM=ENABLE;                        //软件自动离线管理         
    

  90.         CAN_InitStructure.CAN_AWUM=ENABLE;                        //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    

  91.         CAN_InitStructure.CAN_NART=DISABLE;                        //禁止报文自动传送 
    

  92.         CAN_InitStructure.CAN_RFLM=DISABLE;                         //报文不锁定,新的覆盖旧的  
    

  93.         CAN_InitStructure.CAN_TXFP=DISABLE;                        //优先级由报文标识符决定 
    

  94.         CAN_InitStructure.CAN_Mode= CAN_Mode_Normal;                //模式设置： mode:0,普通模式;1,回环模式; 
    

  95.  
    

  96.         //设置波特率  36M/((8+9+1)*4)=500Kbps
    

  97.         CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;                                //重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位  CAN_SJW_1tq         CAN_SJW_2tq CAN_SJW_3tq CAN_SJW_4tq
    

  98.         CAN_InitStructure.CAN_BS1=CAN_BS1_9tq;                         //Tbs1=tbs1+1个时间单位CAN_BS1_1tq ~CAN_BS1_16tq
    

  99.         CAN_InitStructure.CAN_BS2=CAN_BS2_8tq;                                //Tbs2=tbs2+1个时间单位CAN_BS2_1tq ~        CAN_BS2_8tq
    

  100.         CAN_InitStructure.CAN_Prescaler=4;        //分频系数(Fdiv)为brp+1        
    

  101.         CAN_Init(CAN2, &CAN_InitStructure);                //初始化CAN1 
    

  102.  
    

  103.         CAN_FilterInitStructure.CAN_FilterNumber=0;        //过滤器0
    

  104.         CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;         //屏蔽位模式
    

  105.         CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;         //32位宽 
    

  106.         CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;        //32位ID
    

  107.         CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    

  108.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32位MASK
    

  109.         CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    

  110.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;//过滤器0关联到FIFO0
    

  111.         CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;//激活过滤器0
    

  112.  
    

  113.         CAN_FilterInit(CAN2,&CAN_FilterInitStructure);                        //滤波器初始化
    

  114.         
    

  115.  
    

  116.         CAN_ITConfig(CAN2,CAN_IT_FMP0,ENABLE);                                //FIFO0消息挂号中断允许.                    
    

  117.  
    

  118.         NVIC_InitStructure.NVIC_IRQChannel = CAN2_RX0_IRQn;
    

  119.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;     // 主优先级为1
    

  120.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;            // 次优先级为0
    

  121.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    

  122.         NVIC_Init(&NVIC_InitStructure);
    

  123.  
    

  124.         return 0;
    

  125. } 
    

  126.  
    

  127.  
    

  128. //中断服务函数                            
    

  129. void CAN1_RX0_IRQHandler(void)
    

  130. {
    

  131.           CanRxMsg RxMessage;
    

  132.         int i=0;
    

  133.     CAN_Receive(CAN1, 0, &RxMessage);
    

  134.         printf ("CAN1_RX0_IRQHandler:\r\n");
    

  135.         if(RxMessage.StdId==0x12)
    

  136.         {
    

  137.                 printf ("rxbuf:\r\n");
    

  138.                 for(i=0;i<8;i++)
    

  139.                 printf("%02x ",RxMessage.Data[i]);
    

  140.         }
    

  141.         printf("\r\n");
    

  142. }
    

  143.  
    

  144. void CAN2_RX0_IRQHandler(void)
    

  145. {
    

  146.           CanRxMsg RxMessage;
    

  147.         int i=0;
    

  148.     CAN_Receive(CAN2, 0, &RxMessage);
    

  149.         printf ("CAN2_RX0_IRQHandler:\r\n");
    

  150.         if(RxMessage.StdId==0x11)
    

  151.         {
    

  152.                 printf ("rxbuf:\r\n");
    

  153.                 for(i=0;i<8;i++)
    

  154.                 printf("%02x ",RxMessage.Data[i]);
    

  155.         }
    

  156.         printf("\r\n");
    

  157. }
    

  158.  
    

  159.  
    

  160.  
    

  161.  
    

  162. //can发送一组数据(固定格式:ID为0X12,标准帧,数据帧)        
    

  163. //len:数据长度(最大为8)                                     
    

  164. //msg:数据指针,最大为8个字节.
    

  165. //返回值:0,成功;
    

  166. //                 其他,失败;
    

  167. u8 Can1_Send_Msg()
    

  168. {        
    

  169.         u8 mbox;
    

  170.         u16 i=0;
    

  171.         CanTxMsg TxMessage;
    

  172.         TxMessage.StdId=0x11;                        // 标准标识符 
    

  173.         TxMessage.ExtId=0x12;                        // 设置扩展标示符 
    

  174.         TxMessage.IDE=CAN_Id_Standard;         // 标准帧
    

  175.         TxMessage.RTR=CAN_RTR_Data;                // 数据帧
    

  176.         TxMessage.DLC=8;                                // 要发送的数据长度
    

  177.  
    

  178.         TxMessage.Data[0]=0x01;
    

  179.         TxMessage.Data[1]=0x01;
    

  180.         TxMessage.Data[2]=0x01;
    

  181.         TxMessage.Data[3]=0x01;
    

  182.         TxMessage.Data[4]=0x01;
    

  183.         TxMessage.Data[5]=0x01;
    

  184.         TxMessage.Data[6]=0x01;
    

  185.         TxMessage.Data[7]=0x01;        
    

  186.         
    

  187.         mbox= CAN_Transmit(CAN1, &TxMessage);   
    

  188.         i=0; 
    

  189.         while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;        //等待发送结束
    

  190.         if(i>=0XFFF)return 1;
    

  191.         return 0;         
    

  192. }
    

  193.  
    

  194. u8 Can2_Send_Msg()
    

  195. {        
    

  196.         u8 mbox;
    

  197.         u16 i=0;
    

  198.         CanTxMsg TxMessage;
    

  199.         TxMessage.StdId=0x12;                        // 标准标识符 
    

  200.         TxMessage.ExtId=0x12;                        // 设置扩展标示符 
    

  201.         TxMessage.IDE=CAN_Id_Standard;         // 标准帧
    

  202.         TxMessage.RTR=CAN_RTR_Data;                // 数据帧
    

  203.         TxMessage.DLC=8;                                // 要发送的数据长度
    

  204.  
    

  205.         TxMessage.Data[0]=0x02;
    

  206.         TxMessage.Data[1]=0x02;
    

  207.         TxMessage.Data[2]=0x02;
    

  208.         TxMessage.Data[3]=0x02;
    

  209.         TxMessage.Data[4]=0x02;
    

  210.         TxMessage.Data[5]=0x02;
    

  211.         TxMessage.Data[6]=0x02;
    

  212.         TxMessage.Data[7]=0x02;        
    

  213.         
    

  214.         mbox= CAN_Transmit(CAN2, &TxMessage);   
    

  215.         i=0; 
    

  216.         while((CAN_TransmitStatus(CAN2, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))i++;        //等待发送结束
    

  217.         if(i>=0XFFF)return 1;
    

  218.         return 0;         
    

  219. }
    

  220.  
    

  221.  
    

  222. int main(void)
    

  223.  {         
    

  224.  
    

  225.     u8 t=0;
    

  226.         RCC_Config();
    

  227.         delay_init();                     //延时函数初始化          
    

  228.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    

  229.         uart_init(115200);                 //串口初始化为115200
    

  230.         printf ("AT32F403A 替换SXX32f105 双can通讯测试！！\r\n");
    

  231.         AT32LED_Init();                                           
    

  232.  
    

  233.         CAN1_Init(); 
    

  234.         CAN2_Init();
    

  235.  
    

  236.         GetClk();
    

  237.         
    

  238.          while(1)
    

  239.         {                 
    

  240.  
    

  241.                 t++; 
    

  242.                 delay_ms(10);
    

  243.                 if(t%50==0)
    

  244.                 {
    

  245.                         LED4=!LED4;//提示系统正在运行        
    

  246.  
    

  247.                 }
    

  248.                 if(t%100==0)
    

  249.                 {           
    

  250.                         Can1_Send_Msg();
    

  251.                         delay_ms(500);
    

  252.                         Can2_Send_Msg();
    

  253.                         LED2=!LED2;
    

  254.                 }                
    

  255.         }
    

  256. }
    

  257.
测试结果

       通过看串口助手的log，程序已经运行起来，收发的数据和我们设定的是一致的：

5139868d6281c0ff52.png
总结

        AT32F403A的CAN2和STM32F105的CAN2是不一样的，不能兼容。必须修改库才能在AT32上使用，主要就是中断号以及滤波器不一样。



回复

收藏 举报

相关帖子
一点点晚风 发表于 2025-9-30 15:42 | 显示全部楼层
小小总结


相同点：​​
均集成2个CAN控制器（bxCAN），软件兼容。
​​不同点：​​
​​性能​​：AT32主频更高，处理更快。
​​时钟​​：时钟树配置有差异，需修改初始化。
​​库函数​​：需将ST标准库更换为AT32的SDK。

回复

收藏 举报

转瞬回声 发表于 2025-9-30 17:22 | 显示全部楼层
巧了！CAN通讯芯片我也选用的是芯力特的
回复

收藏 举报

小小蚂蚁举千斤 发表于 2025-10-16 17:15 | 显示全部楼层
转瞬回声 发表于 2025-9-30 17:22
巧了！CAN通讯芯片我也选用的是芯力特的

芯力特的芯片还是很不错的
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

AuroraWaltz

7

主题

74

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部