RT-Thread-最近做的一个CAN通信的项目，卡住了RT-Thread问答社区

最近做的一个CAN通信的项目，卡住了

发布于 2020-04-09 16:06:29 浏览：2345 订阅该版

* 本帖最后由 kuailedeluojie 于 2020-4-9 16:12 编辑 *

先交代一下这个项目的来源，之前是用周立功的一个Linux开发板做的嵌入式项目，就是采用cocket can的原始套接字。
目前硬件设计有了新的方案，之前做Linux的那个产品准备用STM32F4的硬件来替换。
因为这个板子和其他被控板的通信就是用CAN通信的。
我用的是STM32F4的芯片。
我在后面慢慢附上主控板和被控板的CAN驱动初始化代码。
首先，附上之前同事做的CAN通信被控板代码，就是驱动部分，用的硬件设计是基于STM32F103的。
只上CAN驱动部分的代码，我在他的代码后面加了备注。
我有两个一样的的硬件，飞线连上CAN，我改了一下两个硬件的ID，两个硬件是可以通过CAN通信的。
```/**
 * @brief initialize gpio
 * 
 */
static void canGpioInit(unsigned int index)
{
    rcu_periph_clock_enable(RCU_AF);
    rcu_periph_clock_enable(RCU_GPIOA);
    /*remap port*/
//    gpio_pin_remap_config(GPIO_CAN_PARTIAL_REMAP,ENABLE);
    nvic_irq_enable(CAN0_RX1_IRQn,0,0);

gpio_init(GPIOA,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_11);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_12);
}```

```/**
 * @brief can initialize
 * 
 * @return int 0:OK 
 */
int canInitialize(unsigned int index)
{
    can_parameter_struct        can_parameter;
    can_filter_parameter_struct can_filter;
    if(index >= MrcCanMax)
    {
        return -1;
    }
    
    rcu_periph_clock_enable(mrcCanAttributeMap[index].rcuPeriph);
    canGpioInit(index); //GPIO初始化
    can_struct_para_init(CAN_INIT_STRUCT, &can_parameter);
    can_struct_para_init(CAN_FILTER_STRUCT, &can_filter);

can_deinit(mrcCanAttributeMap[index].canPeriph);
                //CAN的模式配置  0.5MHZ
    can_parameter.time_triggered = DISABLE;
    can_parameter.auto_bus_off_recovery = DISABLE;
    can_parameter.auto_wake_up = DISABLE;
    can_parameter.auto_retrans = DISABLE;
    can_parameter.rec_fifo_overwrite = DISABLE;
    can_parameter.trans_fifo_order = DISABLE;

can_parameter.working_mode = CAN_NORMAL_MODE;
    /*500kbps 54MHz/12/(1+5+3) = 0.5MHz*/
    can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
    can_parameter.time_segment_1 = CAN_BT_BS1_5TQ;
    can_parameter.time_segment_2 = CAN_BT_BS2_3TQ;
    can_parameter.prescaler = 12;
    can_init(mrcCanAttributeMap[index].canPeriph, &can_parameter);
                //CAN的筛选器配置
    /*CAN0 can_filter.filter_number = 0; CAN1 can_filter.filter_number = 15;*/
    can_filter.filter_number = 0;

can_filter.filter_mode = CAN_FILTERMODE_MASK;

can_filter.filter_bits = CAN_FILTERBITS_32BIT;
    can_filter.filter_list_high = 0x0000;
    can_filter.filter_list_low = 0x0000;
    can_filter.filter_mask_high = 0x0000;
    can_filter.filter_mask_low = 0x0000;
    /*CAN use FIFO1*/
    can_filter.filter_fifo_number = CAN_FIFO1;
    can_filter.filter_enable=ENABLE;
    can_filter_init(&can_filter);
    nvic_irq_enable(mrcCanAttributeMap[index].irqAttribute.irq,mrcCanAttributeMap[index].irqAttribute.priority,mrcCanAttributeMap[index].irqAttribute.subPriority);
    
    clearCanReceiveFlag(index);
    mrcCanAttributeMap[index].initFlag = 0;
    canController.attr = &mrcCanAttributeMap[index];
    initCanThread(); //CAN接收的线程
    return 0;
}
```然后附上我的CAN驱动源码
```/*
<blockquote> 完整配置CAN的功能``````//GPIO配置```配置CAN 的NVIC，第一优先级组，0优先级
```static void CAN_NVIC_Config(void)
{
           NVIC_InitTypeDef NVIC_InitStructure;
                /* Configure one bit for preemption priority */
                NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
                 /*中断设置*/
                NVIC_InitStructure.NVIC_IRQChannel = CAN_RX_IRQ;           //CAN RX中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; 
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                           
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}
```CAN模式的配置
```static void CAN_Mode_Config(void)
{
        CAN_InitTypeDef        CAN_InitStructure;
        /************************CAN通信参数设置**********************************/
        /* Enable CAN clock */
  RCC_APB1PeriphClockCmd(CAN_CLK, ENABLE);

/*CAN 寄存器初始化*/
        CAN_DeInit(CAN1);
        CAN_StructInit(&CAN_InitStructure);

/*CANµ¥Ôª³õÊ¼»¯*/
        CAN_InitStructure.CAN_TTCM=DISABLE;                           //MCR-TTCM 关闭时间触发通信使能模式
        CAN_InitStructure.CAN_ABOM=ENABLE;                           //MCR-ABOM 使能自动离线管理
        CAN_InitStructure.CAN_AWUM=ENABLE;                           //MCR-AWUM使能自动唤醒模式
        CAN_InitStructure.CAN_NART=DISABLE;                           //MCR-NART  禁止报文自动重传   
        CAN_InitStructure.CAN_RFLM=DISABLE;                           //MCR-RFLM 接收FIFO 不锁定溢出时新报文会覆盖原报文 
        CAN_InitStructure.CAN_TXFP=DISABLE;                           //MCR-TXFP  发送FIFO优先级 取决于报文标识符
        CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;  //正常工作模式
        CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;                   //BTR-SJW 重新同步跳跃宽带为 1时间单元
         
        /* ss=1 bs1=5 bs2=3 位时间宽度为(1+5+3)  波特率即为时钟周期 tq*(1+3+5)  */
        CAN_InitStructure.CAN_BS1=CAN_BS1_5tq;                   //BTR-TS1 时间段1 占用了5个时间单元
        CAN_InitStructure.CAN_BS2=CAN_BS2_3tq;                   //BTR-TS1 时间段2 占用了3个时间单元 
        
        /* CAN Baudrate = 1 MBps  APB 1 = 45 MHz) */     
        CAN_InitStructure.CAN_Prescaler =10;                  //BTR-BRP 45/(1+5+3)/5=1 Mbps or /5 = 0.5Mbps
        
        CAN_Init(CANx, &CAN_InitStructure);
}
```CAN 筛选器的配置
```static void CAN_Filter_Config(void)
{
        CAN_FilterInitTypeDef  CAN_FilterInitStructure;

/*CAN筛选器初始化*/
        CAN_FilterInitStructure.CAN_FilterNumber=0;                                                //筛选器组0
        CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;        //工作在掩码模式
        CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;        //筛选器位宽为单个32位

CAN_FilterInitStructure.CAN_FilterIdHigh= ((((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF0000)>>16;  
        CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;  
        CAN_FilterInitStructure.CAN_FilterMaskIdHigh= 0xFFFF; 
        CAN_FilterInitStructure.CAN_FilterMaskIdLow= 0xFFFF;

CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0 ;                                //FIFO0
        CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; 
        CAN_FilterInit(&CAN_FilterInitStructure);

CAN_ITConfig(CANx, CAN_IT_FMP0, ENABLE);
}

```然后就是根据标志位来判断有没有接收到CAN数据的中断函数```void CAN_RX_IRQHandler(void)
{
	/*从邮箱读出报文*/
	CAN_Receive(CANx, CAN_FIFO0, &RxMessage);

/*比较ID是否位0x1314 */
	if((RxMessage.ExtId==0x1314) && (RxMessage.IDE==CAN_ID_EXT) && (RxMessage.DLC==8) )
	{
	flag1 = 1; 					        //接收成功 
	}
	else
	{
	flag1 = 0; 					    //接收失败
	}

}```

以上就是F103和F104的CAN驱动程序，两个不能正常通信，请大神指点。