21ic电子技术开发论坛 › 单片机与嵌入式系统 › AutoChips MCU › 【杰发科技AC7840x测评】+ CAN收发测试
返回列表 发新帖我要提问

[活动专区] 【杰发科技AC7840x测评】+ CAN收发测试

[复制链接]
5708|0
 楼主| tlled 发表于 2023-12-26 23:47 | 显示全部楼层 |阅读模式
AN, CAN, CAN收发, AC, CAN接口
测试下开发板的CAN收发功能。

一、硬件部分

1.1、CAN收发器电路
001.jpg

1.2、CAN接口
CAN接口连接到PE4和PE5端口
002.jpg

1.3、芯片端口映射
PE4和PE5映射到CAN0
003.jpg

二、程序部分

2.1、can.c
复制
  1. #include "ac7840x.h"
    

  2. #include "gpio_drv.h"
    

  3. #include "can_drv.h"
    

  4. #include "can/can.h"
    

  5. #include "osif.h"
    

  6. #include "clock_config.h"
    


  7. 

  8. /* ============================================  Define  ============================================ */
    

  9. #define CAN_SOURCE_CLOCK             (60UL)         /* 时钟源选择60M */
    

  10. #define CAN_MSG_HANDLE_DIRECT        (1UL)          /* 是否处理消息， 1 是， 0 否 */
    

  11. #define CAN_TIME_STAMP_ENABLE        (0UL)          /* 使能/失能CAN时间戳， 1 使能， 0 失能 */
    


  12. 

  13. /* ===========================================  Typedef  ============================================ */
    

  14. typedef struct
    

  15. {
    

  16.     uint32_t recvCount;                              /* 接收消息计数 */
    

  17.     uint32_t sendCount;                              /* 发送消息计数*/
    

  18. } can_cur_node_t;
    


  19. 

  20. /* ==========================================  Variables  =========================================== */
    

  21. /*  
    

  22.  *  波特率和采样点计算公式：
    

  23.  *  tSeg1 = (S_SEG_1 + 2); tSeg2 = (S_SEG_2 + 1).
    

  24.  *  BandRate = (SRC_CLK / (S_PRESC + 1) / ((S_SEG_1 + 2) + (S_SEG_2 + 1))), SRC_CLK 为CAN模块时钟源
    

  25.  *  SamplePoint = (tSeg1 / (tSeg1 + tSeg2)).
    

  26.  */
    

  27. #if (CAN_SOURCE_CLOCK == 80UL)  /*时钟源为80M*/
    

  28. static const can_time_segment_t s_canBitrate[CAN_BITRATE_NUM] =
    

  29. {
    

  30.     {0x1C, 0x09, 0x09, 0x01},  /*   1M, 75% */
    

  31.     {0x26, 0x09, 0x09, 0x01},  /* 800K, 80% */
    

  32.     {0x1C, 0x09, 0x09, 0x03},  /* 500K, 75% */
    

  33.     {0x1C, 0x09, 0x09, 0x07},  /* 250K, 75% */
    

  34.     {0x1C, 0x09, 0x09, 0x0F},  /* 125K, 75% */
    

  35.     {0x1C, 0x09, 0x09, 0x13},  /* 100K, 75% */
    

  36.     {0x1C, 0x09, 0x09, 0x27},  /*  50K, 75% */
    

  37. };
    


  38. 

  39. #elif (CAN_SOURCE_CLOCK == 60UL) /*时钟源为60M*/
    

  40. static const can_time_segment_t s_canBitrate[CAN_BITRATE_NUM] =
    

  41. {
    

  42.     {0x0D, 0x04, 0x04, 0x02},  /*   1M, 75% */
    

  43.     {0x12, 0x04, 0x04, 0x02},  /* 800K, 80% */
    

  44.     {0x1C, 0x09, 0x09, 0x02},  /* 500K, 75% */
    

  45.     {0x1C, 0x09, 0x09, 0x05},  /* 250K, 75% */
    

  46.     {0x1C, 0x09, 0x09, 0x0B},  /* 125K, 75% */
    

  47.     {0x1C, 0x09, 0x09, 0x0E},  /* 100K, 75% */
    

  48.     {0x1C, 0x09, 0x09, 0x1D},  /*  50K, 75% */
    

  49. };
    


  50. 

  51. #elif (CAN_SOURCE_CLOCK == 48UL) /* 时钟源为48M*/
    

  52. static const can_time_segment_t s_canBitrate[CAN_BITRATE_NUM] =
    

  53. {
    

  54.     {0x22, 0x0B, 0x0B, 0x00},  /*   1M, 75% */
    

  55.     {0x16, 0x05, 0x05, 0x01},  /* 800K, 80% */
    

  56.     {0x22, 0x0B, 0x0B, 0x01},  /* 500K, 75%*/
    

  57.     {0x22, 0x0B, 0x0B, 0x03},  /* 250K, 75% */
    

  58.     {0x22, 0x0B, 0x0B, 0x07},  /* 125K, 75% */
    

  59.     {0x22, 0x0B, 0x0B, 0x09},  /* 100K, 75% */
    

  60.     {0x22, 0x0B, 0x0B, 0x13},  /*  50K, 75% */
    

  61. };
    


  62. 

  63. #elif (CAN_SOURCE_CLOCK == 24UL) /* 时钟源为24M*/
    

  64. static const can_time_segment_t s_canBitrate[CAN_BITRATE_NUM] =
    

  65. {
    

  66.     {0x10, 0x05, 0x05, 0x00},  /*   1M, 75% */
    

  67.     {0x16, 0x05, 0x05, 0x00},  /* 800K, 80% */
    

  68.     {0x10, 0x05, 0x05, 0x01},  /* 500K, 75% */
    

  69.     {0x10, 0x05, 0x05, 0x03},  /* 250K, 75% */
    

  70.     {0x10, 0x05, 0x05, 0x07},  /* 125K, 75% */
    

  71.     {0x10, 0x05, 0x05, 0x09},  /* 100K, 75% */
    

  72.     {0x10, 0x05, 0x05, 0x13},  /*  50K, 75% */
    

  73. };
    


  74. 

  75. #elif (CAN_SOURCE_CLOCK == 8UL) /*时钟源为8M*/
    

  76. static const can_time_segment_t s_canBitrate[CAN_BITRATE_NUM] =
    

  77. {
    

  78.     {0x04, 0x01, 0x01, 0x00},  /*   1M，75% */
    

  79.     {0x06, 0x01, 0x01, 0x00},  /* 800K, 80% */
    

  80.     {0x0A, 0x03, 0x03, 0x00},  /* 500K，75% */
    

  81.     {0x0A, 0x03, 0x03, 0x01},  /* 250K，75% */
    

  82.     {0x0A, 0x03, 0x03, 0x03},  /* 125K，75% */
    

  83.     {0x0D, 0x04, 0x03, 0x03},  /* 100K，75% */
    

  84.     {0x0D, 0x04, 0x03, 0x07},  /*  50K，75% */
    

  85. };
    

  86. #endif
    


  87. 

  88. static const can_filter_config_t s_canFilterList[16] =  /* 过滤器配置*/
    

  89. {
    

  90.     {0x00000001, 0x00000000, CAN_MSG_ID_BOTH},         /* 只接收ID 0x0000_0001和0x001的数据 */
    

  91.     {0x00000002, 0x00000000, CAN_MSG_ID_STD},          /* 只接收ID 0x002的标准帧数据 */
    

  92.     {0x00000013, 0x00000000, CAN_MSG_ID_EXT},          /* 只接收ID 0x0000_0013的扩展帧数据 */
    

  93.     {0x00000124, 0x00000000, CAN_MSG_ID_BOTH},         /* 只接收ID 0x0000_0124和0x124的数据 */
    

  94.     {0x00000050, 0x1FFFFF0F, CAN_MSG_ID_BOTH},         /* 可接收ID 0xXXXX_XX5X 或 0xX5X的数据，X为任意值 */
    

  95.     {0x00000060, 0x1FFFFF0F, CAN_MSG_ID_BOTH},         /* 可接收ID 0xXXXX_XX6X 或 0xX6X的数据，X为任意值 */
    

  96.     {0x00000007, 0x1FFFFFF0, CAN_MSG_ID_BOTH},         /* 可接收ID 0xXXXX_XXX7 或 0xXX7的数据，X为任意值 */
    

  97.     {0x00000008, 0x1FFFFFF0, CAN_MSG_ID_BOTH},         /* 可接收ID 0xXXXX_XXX8 或 0xXX8的数据，X为任意值 */
    


  98. 

  99.     {0x00000009, 0x1FFFFFF0, CAN_MSG_ID_STD},          /* 可接收ID 0xXX9的标准帧数据，X为任意值 */
    

  100.     {0x0000000a, 0x1FFFFFF0, CAN_MSG_ID_EXT},          /* 可接收ID 0xXXXX_XXXa的扩展帧数据，X为任意值 */
    

  101.     {0x00000700, 0x1FFFF0FF, CAN_MSG_ID_BOTH},         /* 可接收ID 0xXXXX_X7XX 或 0x7XX的数据，X为任意值 */
    

  102.     {0x0000c000, 0x1FFF0FFF, CAN_MSG_ID_EXT},          /* 可接收ID 0xXXXX_CXXX 的扩展帧数据，X为任意值 */
    

  103.     {0x000d0000, 0x1FF0FFFF, CAN_MSG_ID_EXT},          /* 可接收ID 0xXXXX_DXXX 的扩展帧数据，X为任意值 */
    

  104.     {0x00e00000, 0x1F0FFFFF, CAN_MSG_ID_EXT},          /* 可接收ID 0xXXEX_XXXX 的扩展帧数据，X为任意值 */
    

  105.     {0x0f000000, 0x10FFFFFF, CAN_MSG_ID_EXT},          /* 可接收ID 0xXXXX_XXXX 的扩展帧数据，X为任意值 */
    

  106.     {0x10000000, 0x0FFFFFFF, CAN_MSG_ID_EXT},          /* 可接收ID 0xXXXX_XXXX 的扩展帧数据，X为任意值 */
    

  107. };
    


  108. 

  109. static can_cur_node_t s_canCurNode[CAN_INSTANCE_MAX] = {0}; /* 接收信息*/
    


  110. 

  111. /*!
    

  112.  * [url=home.php?mod=space&uid=247401]@brief[/url] GPIO 初始化
    

  113.  *
    

  114.  * @param[in] instance: CAN 模块通道
    

  115.  * [url=home.php?mod=space&uid=266161]@return[/url] none
    

  116.  */
    

  117. void CAN_InitGPIO(uint8_t instance)
    

  118. {
    

  119.     if (0U == instance)
    

  120.     {
    

  121.         GPIO_DRV_SetMuxModeSel(PORTE, 4U, PORT_MUX_ALT5);           /* CAN0_RX */
    

  122.         GPIO_DRV_SetMuxModeSel(PORTE, 5U, PORT_MUX_ALT5);           /* CAN0_TX */
    

  123.         GPIO_DRV_SetMuxModeSel(PORTE, 10U, PORT_MUX_ALT5);          /* 配置收发器standby功能*/
    

  124.     }
    

  125.     else if (1U == instance)
    

  126.     {
    

  127.         GPIO_DRV_SetMuxModeSel(PORTC, 6U, PORT_MUX_ALT3);           /* CAN1_RX */
    

  128.         GPIO_DRV_SetMuxModeSel(PORTC, 7U, PORT_MUX_ALT3);           /* CAN1_TX */
    

  129.         GPIO_DRV_SetMuxModeSel(PORTE, 6U, PORT_MUX_ALT5);           /* 配置收发器standby功能*/
    

  130.     }
    

  131.     else if (2U == instance)
    

  132.     {
    

  133.         GPIO_DRV_SetMuxModeSel(PORTC, 16U, PORT_MUX_ALT3);          /* CAN2_RX */
    

  134.         GPIO_DRV_SetMuxModeSel(PORTC, 17U, PORT_MUX_ALT3);          /* CAN2_TX */
    

  135.         GPIO_DRV_SetMuxModeSel(PORTC, 15U, PORT_MUX_ALT5);          /* 配置收发器standby功能 */
    

  136.     }
    

  137.     else if (3U == instance)
    

  138.     {
    

  139.         GPIO_DRV_SetMuxModeSel(PORTC, 12U, PORT_MUX_ALT5);          /* CAN3_RX */
    

  140.         GPIO_DRV_SetMuxModeSel(PORTC, 13U, PORT_MUX_ALT5);          /* CAN3_TX */
    

  141.         GPIO_DRV_SetMuxModeSel(PORTC, 11U, PORT_MUX_ALT5);          /* 配置收发器standby功能 */
    

  142.     }
    

  143. }
    


  144. 

  145. /*!
    

  146.  * @brief CAN_GetNormalBitrate 获取波特率
    

  147.  *
    

  148.  * @param[in] index: 波特率索引
    

  149.  * @return 波特率配置
    

  150.  */
    

  151. static can_time_segment_t CAN_GetNormalBitrate(can_bitrate_t index)
    

  152. {
    

  153.     can_time_segment_t bitrate = {0};
    


  154. 

  155.     if (index < CAN_BITRATE_NUM)
    

  156.     {
    

  157.         bitrate = s_canBitrate[index];
    

  158.     }
    


  159. 

  160.     return bitrate;
    

  161. }
    


  162. 

  163. /*!
    

  164.  * @brief CAN_HandleMsg 接收数据处理
    

  165.  *
    

  166.  * @param[in] instance: CAN 模块通道
    

  167.  * @param[in] msgInfo: 接收数据
    

  168.  * @return none
    

  169.  */
    

  170. static void CAN_HandleMsg(uint8_t instance, const can_msg_info_t *msgInfo)
    

  171. {
    

  172.     uint8_t i = 0;
    


  173. 

  174.     s_canCurNode[instance].recvCount++;             /* 节点信息更新 */
    

  175. #if CAN_MSG_HANDLE_DIRECT                           /* 处理数据*/
    

  176.     if (msgInfo->IDE)
    

  177.     {
    

  178.         printf("CAN[%d] RecvCount:%06d ID:%08x DLC:%d", instance, s_canCurNode[instance].recvCount, msgInfo->ID, msgInfo->DLC);
    

  179.     }
    

  180.     else
    

  181.     {
    

  182.         printf("CAN[%d] RecvCount:%06d  ID:%03x DLC:%d", instance, s_canCurNode[instance].recvCount, msgInfo->ID, msgInfo->DLC);
    

  183.     }
    

  184.     if ((0 == msgInfo->RTR) && msgInfo->DLC)
    

  185.     {
    

  186.         printf("\r\tData: ");
    

  187.         for (i = 0; (i < msgInfo->DLC) && (i < 8); i++)
    

  188.         {
    

  189.             printf(" %02x", msgInfo->DATA[i]);
    

  190.         }
    

  191.     }
    

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

  193. #endif
    

  194. }
    


  195. 

  196. /*!
    

  197.  * @brief CAN_EventCallback 中断回调函数， 可通过CAN_IRQHandler了解参数具体含义
    

  198.  *
    

  199.  * @param[in] instance: CAN 模块通道
    

  200.  * @param[in] event: 中断事件
    

  201.  * @param[in] koer: 错误类型
    

  202.  * @return 0: none
    

  203.  */
    

  204. void CAN_EventCallback(uint8_t instance, uint32_t event, uint32_t koer)
    

  205. {
    

  206.     can_msg_info_t recvMsg = {0};
    

  207.     uint8_t recvData[8] = {0};
    


  208. 

  209.     if (event & (uint32_t)CAN_EVENT_BUS_ERROR)         /* 发生错误后，打印错误消息，仅用于调试 */
    

  210.     {
    

  211.         printf("CAN[%d]e: EVEN: %x  KOER: %x\r\n", instance, event, koer);
    

  212.     }
    


  213. 

  214.     if (event & (uint32_t)CAN_EVENT_RECEIVE_DONE)      /* 接收数据*/
    

  215.     {
    

  216.         while (CAN_DRV_GetRbufStatus(instance))
    

  217.         {
    

  218.             recvMsg.DATA = recvData;                   /* 为接收数据索引中的数据域分配空间， 如果未给接收数据索引的数据域分配空间，直操作会触发Haltfault */
    

  219.             if (!CAN_DRV_Receive(instance, &recvMsg))
    

  220.             {
    

  221.                 CAN_HandleMsg(instance, &recvMsg);
    

  222.             }
    

  223.         }
    

  224.     }
    

  225. }
    


  226. 


  227. 


  228. 

  229. void init_can(void)
    

  230. {
    

  231.         uint8_t instance = 0U;
    

  232.         can_user_config_t canCfg = {0};
    

  233.         can_bitrate_t bitrateIndex = CAN_BITRATE_500K;                 /* 低速波特率设置 */
    

  234.         can_transmit_buff_t type = CAN_TRANSMIT_SECONDARY;             /* 发送缓存设置 */
    


  235. 

  236.         canCfg.filterNum = 0U;                                         /* 过滤器数量 */
    

  237.         canCfg.canMode = CAN_NORMAL_MODE;                              /* 正常模式 */
    

  238.         canCfg.interruptEn = true;                                     /* 使能中断*/
    

  239.         canCfg.tsMode = CAN_TSMODE_FIFO;                               /* 选择FIFO模式*/
    

  240.         canCfg.tsAmount = CAN_TRANSMIT_SEC_ALL;                        /* TSALL*/
    

  241.         canCfg.tpss = false;                                           /* 失能PTB单次发送 */
    

  242.         canCfg.tsss = false;                                           /* 失能STB单次发送 */
    

  243.         canCfg.rom = CAN_ROM_OVER_WRITE;                               /* 缓冲区溢出后，新数据会覆盖旧数据*/
    

  244.         canCfg.errorWarningLimit = 0x0BU;                              /* 错误警告限制，当 TECNT|RECTN 超过这个限制，会触发EIF错误中断 */
    

  245. #if CAN_TIME_STAMP_ENABLE
    

  246.         canCfg.timeStampEn = true;                                     /* 时间戳使能 */
    

  247.         canCfg.timeStampClkSrc = CAN_TIME_STAMP_CLK_SRC_EXT;           /* 时间戳时钟源选择 */
    

  248.         canCfg.timeStampClkDiv = CAN_TIME_STAMP_CLK_DIV_8;             /* 时间戳时钟源分频 */
    

  249.         canCfg.timeStampPos = CAN_TIME_STAMP_SOF;                      /* 时间区采样位置选择 */
    

  250. #endif
    

  251.         canCfg.dmaRecvEn = false;                                      /* 不使用DMA */
    

  252.         canCfg.memEccEn = false;                                       /* 失能ECC */
    

  253.         canCfg.wakeupIntEn = false;                                    /* 失能唤醒功能 */
    

  254.         canCfg.busOffRecDisable = false;                               /* 失能自动总线关闭恢复， busoff产生后， 会遵循ISO 11898-规范 */
    

  255.         canCfg.interruptMask = CAN_IRQ_ALL_ENABLE_MSK;                 /* 使能所有中断*/
    

  256.         canCfg.bitrate = CAN_GetNormalBitrate(bitrateIndex);           /* 低速波特率配置*/
    

  257.         canCfg.filterList = (can_filter_config_t *)s_canFilterList;    /* 过滤器配置*/
    

  258.         canCfg.callback = (can_callback_t)CAN_EventCallback;
    

  259.         CAN_InitGPIO(instance);                                        /* CAN模块IO口初始化 */
    

  260.         CAN_DRV_Init(instance, &canCfg);                                                  /* CAN模块初始化 */
    

  261.         
    

  262. }
    


  263. 

  264. void can_senddat(uint8_t *dat)
    

  265. {
    

  266.     int32_t ret = 1;
    

  267.     static can_msg_info_t s_sendMsg = {0};
    

  268.     static uint8_t sendData[8] = {0};
    


  269. 

  270.     if (!CAN_DRV_IsTransmitBusy(0, CAN_TRANSMIT_SECONDARY))
    

  271.     {
    

  272.         s_sendMsg.ID = 0x220;                        /* CAN ID*/
    

  273.         s_sendMsg.IDE = 0;                           /* 标准帧*/
    

  274.         s_sendMsg.RTR = 0;                           /* 非远程帧*/
    

  275.         s_sendMsg.DLC = 8;                           /* 数据长度*/
    

  276.         s_sendMsg.DATA = sendData;                   /* 分配空间*/
    

  277.         s_sendMsg.DATA[0] = dat[0];                    /* 填充数据*/
    

  278.         s_sendMsg.DATA[1] = dat[1];
    

  279.         s_sendMsg.DATA[2] = dat[2];
    

  280.         s_sendMsg.DATA[3] = dat[3];
    

  281.         s_sendMsg.DATA[4] = dat[4];
    

  282.         s_sendMsg.DATA[5] = dat[5];
    

  283.         s_sendMsg.DATA[6] = dat[6];
    

  284.         s_sendMsg.DATA[7] = dat[7];
    

  285.         if (STATUS_SUCCESS == CAN_DRV_Send(0, &s_sendMsg, CAN_TRANSMIT_SECONDARY))
    

  286.         {
    

  287.             s_canCurNode[0].sendCount++;      /* 节点信息更新 */
    

  288.             ret = 0;
    

  289.         }
    

  290.     }
    


  291. 

  292.     return ret;
    

  293. }
    


  294. 


  295. 


  296. 


  297.


2.2、main.c
复制
  1. #include "ac7840x.h"
    

  2. #include "clock_config.h"
    

  3. #include "debugout_ac7840x.h"
    

  4. #include "osif.h"
    

  5. #include "led/led.h"
    

  6. #include "key/key.h"
    

  7. #include "adc/adc.h"
    

  8. #include "spi/spi.h"
    

  9. #include "ch376s.h"
    

  10. #include "can/can.h"
    


  11. 

  12. uint8_t can_txbuf[8];
    


  13. 

  14. void SystemClock_Config(void)
    

  15. {
    

  16.     CKGEN_SYS_Init(g_clockManConfigsArr, CLOCK_MANAGER_CONFIG_CNT,
    

  17.                    g_clockManCallbacksArr, CLOCK_MANAGER_CALLBACK_CNT);
    

  18.     CKGEN_DRV_UpdateConfiguration(0, CLOCK_MANAGER_POLICY_AGREEMENT);
    

  19. }
    


  20. 

  21. int main(void)
    

  22. {
    

  23.         uint8_t i=0;
    

  24.         SystemClock_Config();
    

  25.         init_led();
    

  26.         init_key();
    

  27.         init_adc();
    

  28.         InitDebug();
    

  29.         init_can();
    


  30. 

  31.         while (1)
    

  32.         {
    

  33.                 i++;
    

  34.                 can_txbuf[0]=i;
    

  35.                 can_senddat(can_txbuf);
    

  36.                 led3_on();
    

  37.                 OSIF_TimeDelay(100);
    

  38.                 led3_off();
    

  39.                 OSIF_TimeDelay(100);
    

  40.                 //ADC_TriggerTest();
    

  41.         }
    

  42. }


三、运行结果

3.1、CAN接收测试
打开CAN调试卡，收到开发板发送的数据
004.jpg

3.2、CAN接收测试
串口打印CAN接收到的数据
005.jpg
回复

收藏 举报

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

本版积分规则

tlled

132

主题

701

帖子

7

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