21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › GD32F105RCT6的CAN1通讯只能发不能收，无法进入接收中断 ...
返回列表 发新帖我要提问

[研电赛技术支持] GD32F105RCT6的CAN1通讯只能发不能收，无法进入接收中断

[复制链接]
 楼主| 左左左啊 发表于 2025-6-27 16:38 | 显示全部楼层 |阅读模式
CAN, gd32f1, gd32f105, 通讯
使用GD32F105系列的官方CAN通讯Demo，CAN0可以发可以收，CAN1只能发不能收，查找了好多资料，最后感觉定位在就是滤波器的问题，但是我用keil的debug模式发现无论是CAN0还是CAN1，我更改了滤波器编号，CAN_FW始终不显示我激活了哪个滤波器。这是什么原因，求助求助大佬们，困扰了好久了。下面是官方的demo。
复制
  1. /*!
    

  2.     \file    main.c
    

  3.     \brief   communication_among_Devices in normal mode
    

  4.     
    

  5.     \version 2024-12-20, V2.5.0, firmware for GD32F10x
    

  6. */
    


  7. 

  8. /*
    

  9.     Copyright (c) 2024, GigaDevice Semiconductor Inc.
    


  10. 

  11.     Redistribution and use in source and binary forms, with or without modification, 
    

  12. are permitted provided that the following conditions are met:
    


  13. 

  14.     1. Redistributions of source code must retain the above copyright notice, this 
    

  15.        list of conditions and the following disclaimer.
    

  16.     2. Redistributions in binary form must reproduce the above copyright notice, 
    

  17.        this list of conditions and the following disclaimer in the documentation 
    

  18.        and/or other materials provided with the distribution.
    

  19.     3. Neither the name of the copyright holder nor the names of its contributors 
    

  20.        may be used to endorse or promote products derived from this software without 
    

  21.        specific prior written permission.
    


  22. 

  23.     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
    

  24. AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
    

  25. WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
    

  26. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
    

  27. INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
    

  28. NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
    

  29. PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
    

  30. WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
    

  31. ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
    

  32. OF SUCH DAMAGE.
    

  33. */
    


  34. 

  35. #include "gd32f10x.h"
    

  36. #include <stdio.h>
    

  37. #include "gd32f10x_eval.h"
    


  38. 

  39. /* select can */
    

  40. //#define CAN0_USED
    

  41. #define CAN1_USED
    


  42. 

  43. #ifdef  CAN0_USED
    

  44.     #define CANX CAN0
    

  45. #else 
    

  46.     #define CANX CAN1
    

  47. #endif
    


  48. 

  49. FlagStatus receive_flag;
    

  50. uint8_t transmit_number = 0x0;
    

  51. can_trasnmit_message_struct g_transmit_message;
    

  52. can_receive_message_struct g_receive_message;
    

  53.     
    

  54. void nvic_config(void);
    

  55. void led_config(void);
    

  56. void gpio_config(void);
    

  57. ErrStatus can_networking(void);
    

  58. void can_networking_init(void);
    

  59. void delay(void);
    


  60. 

  61. /*!
    

  62.     \brief      main function
    

  63.     \param[in]  none
    

  64.     \param[out] none
    

  65.     \retval     none
    

  66. */
    

  67. int main(void)
    

  68. {
    

  69.     uint8_t i = 0;
    

  70.     uint32_t timeout = 0xFFFF;
    

  71.     uint8_t transmit_mailbox = 0;
    

  72.     
    

  73.     receive_flag = RESET;
    

  74.     /* configure Tamper key */
    

  75.     gd_eval_key_init(KEY_TAMPER, KEY_MODE_GPIO);
    

  76.     /* configure GPIO */
    

  77.     gpio_config();
    

  78.     /* configure USART */
    

  79.     gd_eval_com_init(EVAL_COM0);
    

  80.     /* configure NVIC */
    

  81.     nvic_config();
    

  82.     /* configure leds */
    

  83.     led_config();
    

  84.     /* set all leds off */
    

  85.     gd_eval_led_off(LED2);
    

  86.     gd_eval_led_off(LED3);
    

  87.     gd_eval_led_off(LED4);
    

  88.     /* initialize CAN */
    

  89.     can_networking_init();
    

  90.     
    

  91.     /* enable CAN receive FIFO1 not empty interrupt */
    

  92.     can_interrupt_enable(CANX, CAN_INT_RFNE1);
    

  93. //     can_interrupt_enable(CAN1, CAN_INT_RFNE1);
    

  94.     /* initialize transmit message */
    

  95.     can_struct_para_init(CAN_TX_MESSAGE_STRUCT, &g_transmit_message);
    

  96.                 
    

  97.     g_transmit_message.tx_sfid = 0x00;
    

  98.     g_transmit_message.tx_efid = 0xaabb;
    

  99.     g_transmit_message.tx_ft = CAN_FT_DATA;
    

  100.     g_transmit_message.tx_ff = CAN_FF_EXTENDED;
    

  101.     g_transmit_message.tx_dlen = 8;
    

  102.     
    

  103.     g_transmit_message.tx_data[0] = 0xA0U;
    

  104.     g_transmit_message.tx_data[1] = 0xA1U;
    

  105.     g_transmit_message.tx_data[2] = 0xA2U;
    

  106.     g_transmit_message.tx_data[3] = 0xA3U;
    

  107.     g_transmit_message.tx_data[4] = 0xA4U;
    

  108.     g_transmit_message.tx_data[5] = 0xA5U;
    

  109.     g_transmit_message.tx_data[6] = 0xA6U;
    

  110.     g_transmit_message.tx_data[7] = 0xA7U;
    

  111.     
    

  112.     printf("please press the Tamper key to transmit data!\r\n");
    

  113.     
    

  114.     /* initialize receive message */
    

  115.     can_struct_para_init(CAN_RX_MESSAGE_STRUCT, &g_receive_message);
    

  116.     
    

  117.     while(1) {
    

  118.         /* waiting for the Tamper key pressed */
    

  119.         while(0 == gd_eval_key_state_get(KEY_TAMPER)){
    

  120.             /* if transmit_number is 0x10, set it to 0x00 */
    

  121.             if(transmit_number == 0x10){
    

  122.                 transmit_number = 0x00;
    

  123.             }else{
    

  124.                 g_transmit_message.tx_data[0] = transmit_number++;
    

  125.                 printf("\r\n can transmit data:");
    

  126.                 for(i = 0; i < g_transmit_message.tx_dlen; i++){
    

  127.                     printf(" %02x", g_transmit_message.tx_data[i]);
    

  128.                 }
    

  129.                 /* transmit message */
    

  130.                 transmit_mailbox = can_message_transmit(CANX, &g_transmit_message);
    

  131.                 /* waiting for transmit completed */
    

  132.                 timeout = 0xFFFF;
    

  133.                 while((CAN_TRANSMIT_OK != can_transmit_states(CANX, transmit_mailbox)) && (0 != timeout)){
    

  134.                     timeout--;
    

  135.                 }
    

  136.                 /* waiting for Tamper key up */
    

  137.                 while(0 == gd_eval_key_state_get(KEY_TAMPER));
    

  138.             }
    

  139.         }
    

  140.         if(SET == receive_flag) {
    

  141.             gd_eval_led_toggle(LED2);
    

  142.             receive_flag = RESET;
    

  143.             printf("\r\n receive data:");
    

  144.             for(i = 0; i < g_receive_message.rx_dlen; i++){
    

  145.                 printf(" %02x", g_receive_message.rx_data[i]);
    

  146.             }
    

  147.         }
    

  148.     }
    

  149. }
    


  150. 

  151. /*!
    

  152.     \brief      initialize CAN and filter
    

  153.     \param[in]  can_parameter
    

  154.       \arg        can_parameter_struct
    

  155.     \param[in]  can_filter
    

  156.       \arg        can_filter_parameter_struct
    

  157.     \param[out] none
    

  158.     \retval     none
    

  159. */
    

  160. void can_networking_init(void)
    

  161. {
    

  162.     can_parameter_struct            can_parameter;
    

  163.     can_filter_parameter_struct     can_filter;
    

  164.     
    

  165.     can_struct_para_init(CAN_INIT_STRUCT, &can_parameter);
    

  166.     can_struct_para_init(CAN_FILTER_STRUCT, &can_filter);
    

  167.     
    

  168.     /* initialize CAN register */
    

  169.     can_deinit(CANX);
    

  170.     
    

  171.     /* initialize CAN */
    

  172.     can_parameter.time_triggered = DISABLE;
    

  173.     can_parameter.auto_bus_off_recovery = DISABLE;
    

  174.     can_parameter.auto_wake_up = DISABLE;
    

  175.     can_parameter.auto_retrans = DISABLE;
    

  176.     can_parameter.rec_fifo_overwrite = DISABLE;
    

  177.     can_parameter.trans_fifo_order = DISABLE;
    

  178.     can_parameter.working_mode = CAN_NORMAL_MODE;
    

  179.     can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
    

  180.     can_parameter.time_segment_1 = CAN_BT_BS1_5TQ;
    

  181.     can_parameter.time_segment_2 = CAN_BT_BS2_3TQ;
    

  182.     /* baudrate 250kbps */
    

  183.     can_parameter.prescaler = 24;
    

  184.     can_init(CANX, &can_parameter);
    

  185.     /* initialize filter */
    


  186. 

  187. #ifdef  CAN0_USED
    

  188.     /* CAN0 filter number */
    

  189.     can_filter.filter_number = 0;
    

  190. #else
    

  191.     /* CAN1 filter number */
    

  192.     can_filter.filter_number = 15;
    

  193. #endif
    

  194.     /* initialize filter */    
    

  195.     can_filter.filter_mode = CAN_FILTERMODE_MASK;
    

  196.     can_filter.filter_bits = CAN_FILTERBITS_32BIT;
    

  197.     can_filter.filter_list_high = 0x0000U;
    

  198.     can_filter.filter_list_low = 0x0000U;
    

  199.     can_filter.filter_mask_high = 0x0000U;
    

  200.     can_filter.filter_mask_low = 0x0000U;  
    

  201.     can_filter.filter_fifo_number = CAN_FIFO1;
    

  202.     can_filter.filter_enable = ENABLE;
    

  203.     can_filter_init(&can_filter);
    


  204. 

  205. }
    


  206. 

  207. /*!
    

  208.     \brief      configure the nested vectored interrupt controller
    

  209.     \param[in]  none
    

  210.     \param[out] none
    

  211.     \retval     none
    

  212. */
    

  213. void nvic_config(void)
    

  214. {
    

  215. #ifdef  CAN0_USED
    

  216.     /* configure CAN0 NVIC */
    

  217.     nvic_irq_enable(CAN0_RX1_IRQn,0,0);
    

  218. #else
    

  219.     /* configure CAN1 NVIC */
    

  220.     nvic_irq_enable(CAN1_RX1_IRQn,0,0);
    

  221. #endif
    


  222. 

  223. }
    


  224. 

  225. /*!
    

  226.     \brief      delay
    

  227.     \param[in]  none
    

  228.     \param[out] none
    

  229.     \retval     none
    

  230. */
    

  231. void delay(void)
    

  232. {
    

  233.     uint16_t nTime = 0x0000;
    


  234. 

  235.     for(nTime = 0; nTime < 0xFFFF; nTime++){
    

  236.     }
    

  237. }
    


  238. 

  239. /*!
    

  240.     \brief      configure the leds
    

  241.     \param[in]  none
    

  242.     \param[out] none
    

  243.     \retval     none
    

  244. */
    

  245. void led_config(void)
    

  246. {
    

  247.     gd_eval_led_init(LED2);
    

  248.     gd_eval_led_init(LED3);
    

  249.     gd_eval_led_init(LED4);
    

  250. }
    


  251. 

  252. /*!
    

  253.     \brief      configure GPIO
    

  254.     \param[in]  none
    

  255.     \param[out] none
    

  256.     \retval     none
    

  257. */
    

  258. void gpio_config(void)
    

  259. {
    

  260.     /* enable CAN clock */
    

  261.     rcu_periph_clock_enable(RCU_CAN0);
    

  262.                 rcu_periph_clock_enable(RCU_CAN1);
    

  263.           rcu_periph_clock_enable(RCU_GPIOB);
    

  264.     rcu_periph_clock_enable(RCU_AF);
    

  265.     
    

  266.     /* configure CAN0 GPIO */
    

  267.     gpio_init(GPIOB,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
    

  268.     gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9);
    

  269.     gpio_pin_remap_config(GPIO_CAN0_PARTIAL_REMAP,ENABLE);
    

  270.         
    

  271.           gpio_init(GPIOB,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_5);
    

  272.     gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_6);
    

  273.     gpio_pin_remap_config(GPIO_CAN1_REMAP,ENABLE);
    

  274. }
    


  275. 

  276. #ifdef GD_ECLIPSE_GCC
    

  277. /* retarget the C library printf function to the USART, in Eclipse GCC environment */
    

  278. int __io_putchar(int ch)
    

  279. {
    

  280.     usart_data_transmit(EVAL_COM0, (uint8_t) ch );
    

  281.     while(RESET == usart_flag_get(EVAL_COM0, USART_FLAG_TBE));
    

  282.     return ch;
    

  283. }
    

  284. #else
    

  285. /* retarget the C library printf function to the USART */
    

  286. int fputc(int ch, FILE *f)
    

  287. {
    

  288.     usart_data_transmit(EVAL_COM0, (uint8_t)ch);
    

  289.     while(RESET == usart_flag_get(EVAL_COM0, USART_FLAG_TBE));
    

  290.     return ch;
    

  291. }
    

  292. #endif /* GD_ECLIPSE_GCC */
中断的回调函数如下：
复制
  1. void CAN0_RX1_IRQHandler(void)
    

  2. {
    

  3.     /* check the receive message */
    

  4.     can_message_receive(CAN0, CAN_FIFO1, &g_receive_message);
    

  5. //    if((0xaabb == g_receive_message.rx_efid)&&(CAN_FF_EXTENDED == g_receive_message.rx_ff) && (8 == g_receive_message.rx_dlen)){
    

  6.         receive_flag = SET;
    

  7. //    }
    

  8. }
    


  9. 

  10. /*!
    

  11.     \brief      this function handles CAN1 RX0 exception
    

  12.     \param[in]  none
    

  13.     \param[out] none
    

  14.     \retval     none
    

  15. */
    

  16. void CAN1_RX1_IRQHandler(void)
    

  17. {
    

  18. //    printf("get!!\r\n");
    

  19.     /* check the receive message */
    

  20.     can_message_receive(CAN1, CAN_FIFO1, &g_receive_message);
    

  21. //    if((0xaabb == g_receive_message.rx_efid)&&(CAN_FF_EXTENDED == g_receive_message.rx_ff) && (8 == g_receive_message.rx_dlen)){
    

  22.         receive_flag = SET;
    

  23. //    }
    

  24. }
使用debug模式看了CAN_FW中激活的滤波器，发现没有打√的，是不是就代表没激活，导致我进不去中断。图片如图
12106685e581cc48fa.png
9634685e581d9f2dd.png
FIFO1的相应中断也开了，能接收到数据
98546685e58627bae6.png
各位大佬，请求指点迷津。




回复 赏

举报

评论

左左左啊
大佬们求支招  发表于 2025-6-28 11:03

相关帖子
 楼主| 左左左啊 发表于 2025-7-1 16:04 | 显示全部楼层
问题已解决，是启动文件没有配置好
回复 赏

举报

liangzidefannao 发表于 2025-8-19 17:21 | 显示全部楼层
左左左啊 发表于 2025-7-1 16:04
问题已解决，是启动文件没有配置好

问下是启动文件哪里需要配置呀
回复 赏

举报

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

本版积分规则

左左左啊

1

主题

3

帖子

0

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