RT-Thread-gd32f103 CAN 驱动RT-Thread问答社区

gd32f103 CAN 驱动

发布于 2023-09-18 15:26:58 浏览：1238 订阅该版

现在是2023年9月19日，RT thread官网还是没有关于gd32的can驱动，对于不想放弃RT thread的朋友，可以考虑脱离系统，直接初始化can，接收采用中断的方式实现。以下是使用gd32初始化的驱动代码，仅供参考。

```c
#include "gd32f10x.h"
#include <stdio.h>
//#include "gd32f10x_eval.h"

/* select CAN baudrate */
/* 1MBps */
//#define CAN_BAUDRATE  1000
/* 500kBps */
/* #define CAN_BAUDRATE  500 */
/* 250kBps */
#define CAN_BAUDRATE  250
/* 125kBps */
/* #define CAN_BAUDRATE  125 */
/* 100kBps */ 
/* #define CAN_BAUDRATE  100 */
/* 50kBps */ 
/* #define CAN_BAUDRATE  50 */
/* 20kBps */ 
/* #define CAN_BAUDRATE  20 */

FlagStatus can0_receive_flag;
FlagStatus can1_receive_flag;
FlagStatus can0_error_flag;
FlagStatus can1_error_flag;
can_parameter_struct can_init_parameter;
can_filter_parameter_struct can_filter_parameter;
can_trasnmit_message_struct transmit_message;
can_receive_message_struct receive_message;

void nvic_config(void);
void can_gpio_config(void);
void can_config(can_parameter_struct can_parameter, can_filter_parameter_struct can_filter);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
void can_init_config(void)
{
    can0_receive_flag = RESET;
    can1_receive_flag = RESET;
    can0_error_flag = RESET;
    can1_error_flag = RESET;
    
    /* configure GPIO */
    can_gpio_config();
    
    /* configure NVIC */
    nvic_config();
    
    /* initialize CAN and filter */
    can_config(can_init_parameter, can_filter_parameter);
    /* enable can receive FIFO1 not empty interrupt 
       Because we can only use 'CAN0_RX1_IRQHandler' as interrupt interface,
       it's not CAN0_RX0..., so we only can use CAN_FIFO1 not CAN_FIFO0
       inferred from this.*/
    can_interrupt_enable(CAN0, CAN_INT_RFNE1);//CAN_INT_RFNE0
}

void can_sendmsg(uint8_t *msg, uint8_t len)
{
    uint8_t cnt = 0;
    static uint8_t add = 0;
    /* initialize transmit message */
    transmit_message.tx_sfid = 0x7ab;//0x300>>1;
    transmit_message.tx_efid = 0x00;//0x18100140;
    transmit_message.tx_ft = CAN_FT_DATA;
    transmit_message.tx_ff = CAN_FF_STANDARD;
    transmit_message.tx_dlen = 2;
    
    for(; cnt < len; cnt++)
        transmit_message.tx_data[cnt] = msg[cnt];
    
    msg[1] = add++;
    
    can_message_transmit(CAN0, &transmit_message);
}

/*!
    \brief      initialize CAN and filter
    \param[in]  can_parameter
      \arg        can_parameter_struct
    \param[in]  can_filter
      \arg        can_filter_parameter_struct
    \param[out] none
    \retval     none
*/
void can_config(can_parameter_struct can_parameter, can_filter_parameter_struct can_filter)
{
    can_struct_para_init(CAN_INIT_STRUCT, &can_parameter);
    can_struct_para_init(CAN_INIT_STRUCT, &can_filter);
    /* initialize CAN register */
    can_deinit(CAN0);
    
    /* initialize CAN parameters */
    can_parameter.time_triggered = DISABLE;
    can_parameter.auto_bus_off_recovery = DISABLE;//ENABLE;//
    can_parameter.auto_wake_up = DISABLE;//ENABLE;//
    can_parameter.auto_retrans = ENABLE;//DISABLE;//       //no_auto_retrans->auto_retrans 23.8.28
    can_parameter.rec_fifo_overwrite = DISABLE;
    can_parameter.trans_fifo_order = DISABLE;
    can_parameter.working_mode = CAN_NORMAL_MODE;//CAN_LOOPBACK_MODE;//
    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;
    
    /* 1MBps */
#if CAN_BAUDRATE == 1000
    can_parameter.prescaler = 6;
    /* 500KBps */
#elif CAN_BAUDRATE == 500
    can_parameter.prescaler = 12;
    /* 250KBps */
#elif CAN_BAUDRATE == 250
    can_parameter.prescaler = 24;
    /* 125KBps */
#elif CAN_BAUDRATE == 125
    can_parameter.prescaler = 48;
    /* 100KBps */
#elif  CAN_BAUDRATE == 100
    can_parameter.prescaler = 60;
    /* 50KBps */
#elif  CAN_BAUDRATE == 50
    can_parameter.prescaler = 120;
    /* 20KBps */
#elif  CAN_BAUDRATE == 20
    can_parameter.prescaler = 300;
#else
    #error "please select list can baudrate in private defines in main.c "
#endif  
    /* initialize CAN */
    can_init(CAN0, &can_parameter);
    
    /* initialize filter */ 
    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;//0x3000;//(((uint32_t)0x7FF<<21|CAN_FT_DATA|CAN_FF_STANDARD)&0xFFFF0000)>>16;//
    can_filter.filter_list_low    = 0x0000;//(((uint32_t)0x7FF<<21|CAN_FT_DATA|CAN_FF_STANDARD)&0xFFFF0000)&0x0000FFFF;//
    can_filter.filter_mask_high   = 0x0000;//0x3000;//0xFFE0;
    can_filter.filter_mask_low    = 0x0000;//0x0006;
    can_filter.filter_fifo_number = CAN_FIFO1;//CAN_FIFO0;
    can_filter.filter_enable      = ENABLE;//DISABLE;//
    
    can_filter_init(&can_filter);
    
    /* CAN1 filter number */
    can_filter.filter_number = 15;
    can_filter_init(&can_filter);
}

/*!
    \brief      configure the nested vectored interrupt controller
    \param[in]  none
    \param[out] none
    \retval     none
*/
void nvic_config(void)
{
    /* configure CAN0 NVIC */
    nvic_irq_enable(CAN0_RX1_IRQn,0,0); 
}

/*!
    \brief      configure GPIO
    \param[in]  none
    \param[out] none
    \retval     none
*/
void can_gpio_config(void)
{
    /* enable CAN clock */
    rcu_periph_clock_enable(RCU_CAN0);
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);
       
    /* configure CAN0 GPIO */
    gpio_init(GPIOA,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_11);   //rx
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_12); //tx
//    gpio_pin_remap_config(GPIO_CAN0_REMAP,ENABLE);
}
```
接收中断只需要调用can_message_receive即可，代码如下

```c
void CAN0_RX1_IRQHandler(void)
{
    can_message_receive(CAN0, CAN_FIFO1, &receive_message);
}
```