标题: STC32G12K128单片机的CAN连续收发问题 [打印本页]
作者: 的花朵    时间: 2022-6-27 18:41
标题: STC32G12K128单片机的CAN连续收发问题
如题，目前在STC32G单片机上做开发，要用到CAN总线，按照例程配置了一下，测试单次收发没有问题，但是连续收发单片机总会收多或收少，少的时候能少几十帧，多的时候也能多几十帧，应该是我的配置问题，求大佬指点哇，我的配置如下:
  1. #include "can.h"
  2. #include "config.h"
  3. #include "STC32G_NVIC.h"

  5. #define DBG_TAG "can"
  6. #include "debug.h"

  8. // can 设备句柄
  9. static can_t can1 = { 0 };
  10. static can_t can2 = { 0 };
  11. /* 初始化can设备 */
  12. void can_init(u8 channel, u8 port, u8 pin, u8 io_mux, u32 buad)
  13. {
  14.         can_t *can_dev;
  15.         u32 tmp_brp,tmp_tsg,buad_cal;
  16.         CAN_InitTypeDef        CAN_InitStructure;                                                //结构定义
  17.         GPIO_InitTypeDef        GPIO_InitStructure;                                        //结构定义
  18.         // update
  19.         if(channel == CAN1)
  20.         {
  21.                 can_dev = &can1;
  22.                 CAN1_SW(io_mux);
  23.         }
  24.         else if(channel == CAN2)
  25.         {
  26.                 can_dev = &can2;
  27.                 CAN2_SW(io_mux);
  28.         }
  29.         else
  30.         {
  31.                 return;
  32.         }
  33.         /*IO INIT*/
  34.         GPIO_InitStructure.Pin  = pin;                                                                //指定要初始化的IO, GPIO_Pin_0 ~ GPIO_Pin_7
  35.         GPIO_InitStructure.Mode = GPIO_PullUp;                                                //指定IO的输入或输出方式,GPIO_PullUp,GPIO_HighZ,GPIO_OUT_OD,GPIO_OUT_PP
  36.         GPIO_Inilize(port,&GPIO_InitStructure);                                                //初始化
  37.         
  38.         CAN_InitStructure.CAN_Enable = ENABLE;                                                //CAN功能使能   ENABLE或DISABLE
  39.         CAN_InitStructure.CAN_IMR = CAN_RIM | CAN_BEIM;                                //CAN中断寄存器         CAN_DOIM,CAN_BEIM,CAN_TIM,CAN_RIM,CAN_EPIM,CAN_EWIM,CAN_ALIM,CAN_ALLIM,DISABLE
  40.         CAN_InitStructure.CAN_SJW    = 3;                                                        //重新同步跳跃宽度  0~3
  41.         CAN_InitStructure.CAN_SAM    = 1;                                                        //总线电平采样次数  0:采样1次; 1:采样3次
  42.         //CAN总线波特率=Fclk/((1+(TSG1+1)+(TSG2+1))*(BRP+1)*2)
  43.         buad_cal = (MAIN_Fosc / buad) / 2;
  44.         if(buad_cal <= 0)
  45.         {
  46.                 return;
  47.         }
  48.         for(tmp_tsg = 1 + 2 + 1; tmp_tsg < 26; tmp_tsg ++)
  49.         {
  50.                 for(tmp_brp = 1; tmp_brp < 64; tmp_brp ++)
  51.                 {
  52.                         if(buad_cal < tmp_brp * tmp_tsg)
  53.                         {
  54.                                 break;
  55.                         }
  56.                         if(buad_cal == tmp_brp * tmp_tsg)
  57.                         {
  58.                                 break;
  59.                         }
  60.                 }        
  61.                 if(buad_cal == tmp_brp * tmp_tsg)
  62.                 {
  63.                         break;
  64.                 }
  65.         }
  66.         if(tmp_tsg < 11)
  67.         {
  68.                 CAN_InitStructure.CAN_TSG1   = 0;                                //同步采样段1       0~15
  69.                 CAN_InitStructure.CAN_TSG2   = tmp_tsg - 3;                //同步采样段2       1~7 (TSG2 不能设置为0)                        
  70.         }
  71.         else if(tmp_tsg < 26)
  72.         {
  73.                 CAN_InitStructure.CAN_TSG1   = tmp_tsg - 10;        //(1 + 1 + 1 + CAN_TSG2)
  74.                 CAN_InitStructure.CAN_TSG2   = 7;                                //同步采样段2       1~7 (TSG2 不能设置为0)        
  75.         }
  76.         CAN_InitStructure.CAN_BRP    = tmp_brp - 1;                        //波特率分频系数    0~63        
  77.                
  78.         CAN_InitStructure.CAN_ACR0    = 0x00;                                //总线验收代码寄存器 0~0xFF
  79.         CAN_InitStructure.CAN_ACR1    = 0x00;
  80.         CAN_InitStructure.CAN_ACR2    = 0x00;
  81.         CAN_InitStructure.CAN_ACR3    = 0x00;
  82.         CAN_InitStructure.CAN_AMR0    = 0xff;                                //总线验收屏蔽寄存器 0~0xFF
  83.         CAN_InitStructure.CAN_AMR1    = 0xff;
  84.         CAN_InitStructure.CAN_AMR2    = 0xff;
  85.         CAN_InitStructure.CAN_AMR3    = 0xff;
  86.         //CAN1 初始化
  87.         CAN_Inilize(channel,&CAN_InitStructure);        
  88.         //中断使能
  89.         NVIC_CAN_Init(channel,ENABLE,Priority_0);
  90.         //
  91.         can_dev->buad = buad;
  92.         can_dev->channel = channel;
  93.         can_dev->queue.current = can_dev->queue.can_context_pool + 1;
  94.         can_dev->queue.tail = can_dev->queue.can_context_pool + 1;
  95.         memset(can_dev->queue.can_context_pool, 0, sizeof(can_dev->queue.can_context_pool));
  96.         
  97.         LOG_I(DBG_TAG, "can_dev queue tail = 0x%p", can_dev->queue.tail);
  98.         LOG_I(DBG_TAG, "can_dev queue current = 0x%p", can_dev->queue.current);
  99.         LOG_I(DBG_TAG, "can_dev queue can_context_pool = 0x%p", can_dev->queue.can_context_pool);
  100.         LOG_I(DBG_TAG, "can_dev queue can_context_pool tail = 0x%p", can_dev->queue.can_context_pool + CAN_QUEUE_POOL_SIZE);
  101.         LOG_I(DBG_TAG, "can%d init success!", channel + 1);
  102. }
  103. /* 绑定命令表到某个can通道上 */
  104. void can_command_load(u8 channel, can_command_t *command_table)
  105. {
  106.         can_t *can_dev;
  107.         can_dev = channel == CAN1 ? &can1: &can2;
  108.         can_dev->command_table = command_table;
  109. }
  110. /* 查询队列中是否有元素 */
  111. bool can_queue_is_empty(u8 channel)
  112. {
  113.         can_t *can_dev;
  114.         can_dev = channel == CAN1 ? &can1: &can2;
  115.         if((can_dev->queue.current == can_dev->queue.tail) && (can_dev->queue.can_context_pool[0].cmd == 0x00))
  116.         {
  117.                 return TRUE;
  118.         }
  119.         LOG_D(DBG_TAG, "can_dev->queue.can_context_pool[0].cmd = 0x%p", can_dev->queue.can_context_pool[0].cmd);
  120.         LOG_D(DBG_TAG,         "can queue ptr tail = 0x%p can queue ptr current = 0x%p",
  121.                                         can_dev->queue.tail,
  122.                                         can_dev->queue.current);
  123.         return FALSE;
  124. }
  125. /* 吐出一个队列中的元素 */
  126. can_context_t can_queue_pop(u8 channel)
  127. {
  128.         can_t* can_dev;
  129.         can_context_t* context = NULL;
  130.         can_context_t ret = { 0 };
  131.         can_dev = channel == CAN1 ? &can1 : &can2;
  132.         // 存在紧急命令时优先吐出
  133.         if (can_dev->queue.can_context_pool[0].cmd != 0x00)
  134.         {
  135.                 context = &(can_dev->queue.can_context_pool[0]);
  136.         }
  137.         else
  138.         {
  139.                 context = can_dev->queue.current;
  140.                 // 准备下次pop
  141.                 if (can_dev->queue.current < can_dev->queue.tail)
  142.                 {
  143.                         can_dev->queue.current += 1;
  144.                 }
  145.                 // current,tail指针地址重叠
  146.                 else if (can_dev->queue.current == can_dev->queue.tail)
  147.                 {
  148.                         // 地址上有内容
  149.                         if (can_dev->queue.tail->cmd == 0x00)
  150.                         {
  151.                                 context = NULL;
  152.                         }
  153.                 }
  154.                 // current指针大于tail指针
  155.                 else
  156.                 {
  157.                         if (can_dev->queue.current < can_dev->queue.can_context_pool + CAN_QUEUE_POOL_SIZE)
  158.                         {
  159.                                 can_dev->queue.current += 1;
  160.                         }
  161.                         else
  162.                         {
  163.                                 can_dev->queue.current = can_dev->queue.can_context_pool + 1;
  164.                         }
  165.                 }
  166.         }
  167.         if (context)
  168.         {
  169.                 ret = *context;
  170.                 // 清空context为下次数据填充做准备
  171.                 memset(context, 0, sizeof(can_context_t));
  172.         }
  173.         return ret;
  174. }

  176. /* 向队列中压入元素 */
  177. bool can_queue_push(u8 channel, can_context_t* context)
  178. {
  179.         can_t* can_dev;
  180.         can_dev = channel == CAN1 ? &can1 : &can2;
  181.         // 优先写入紧急命令
  182.         if (context->cmd < 0x10)
  183.         {
  184.                 can_dev->queue.can_context_pool[0] = *context;
  185.                 return TRUE;
  186.         }
  187.         // tail指针向下偏移
  188.         if (can_dev->queue.tail <= can_dev->queue.can_context_pool + CAN_QUEUE_POOL_SIZE)
  189.         {
  190.                 if (can_dev->queue.tail + 1 == can_dev->queue.current)
  191.                 {
  192.                         // 地址上已有内容，返回队列已满
  193.                         if (can_dev->queue.tail->cmd)
  194.                         {
  195.                                 return FALSE;
  196.                         }
  197.                         else
  198.                         {
  199.                                 *(can_dev->queue.tail) = *context;
  200.                         }
  201.                 }
  202.                 // 只要不遇到current指针就总是移动
  203.                 else
  204.                 {
  205.                         *(can_dev->queue.tail) = *context;
  206.                         can_dev->queue.tail += 1;
  207.                 }
  208.         }
  209.         else
  210.         {
  211.                 if (can_dev->queue.current != can_dev->queue.can_context_pool + 1)
  212.                 {
  213.                         can_dev->queue.tail = can_dev->queue.can_context_pool + 1;
  214.                         *(can_dev->queue.tail) = *context;
  215.                 }
  216.                 if (can_dev->queue.tail > can_dev->queue.can_context_pool + CAN_QUEUE_POOL_SIZE)
  217.                 {
  218.                         return FALSE;
  219.                 }
  220.         }
  221.         return TRUE;
  222. }
  223. /* 通过命令号获取命令句柄 */
  224. can_command_t *can_command_get(u8 channel, u8 cmd)
  225. {
  226.         u8 find;
  227.         can_t *can_dev;
  228.         can_dev = channel == CAN1 ? &can1: &can2;
  229.         for(find = 0; can_dev->command_table[find].type != CAN_COMMAND_END; find ++)
  230.         {
  231.                 if(can_dev->command_table[find].cmd == cmd)
  232.                         break;
  233.         }
  234.         return &(can_dev->command_table[find]);
  235. }
  236. /* 发送标准帧 */
  237. void can_send_standard_frame(u8 channel, u16 up_id, u8 *pdat)
  238. {
  239.         u16 CanID;
  240.         can_t *can_dev;
  241.         can_dev = channel == CAN1 ? &can1: &can2;
  242.         
  243.         CANSEL = channel;
  244.         CanID = up_id << 5;
  245.         
  246.         CANAR = TX_BUF0;CANDR = 0x08;
  247.         CANAR = TX_BUF1;CANDR = CanID >> 8;
  248.         CANAR = TX_BUF2;CANDR = CanID;
  249.         CANAR = TX_BUF3;CANDR = pdat[0];
  250.         CANAR = TX_BUF0;CANDR = pdat[1];
  251.         CANAR = TX_BUF1;CANDR = pdat[2];
  252.         CANAR = TX_BUF2;CANDR = pdat[3];
  253.         CANAR = TX_BUF3;CANDR = pdat[4];
  254.         CANAR = TX_BUF0;CANDR = pdat[5];
  255.         CANAR = TX_BUF1;CANDR = pdat[6];
  256.         CANAR = TX_BUF2;CANDR = pdat[7];
  257.         CANAR = TX_BUF3;CANDR = 0x00;
  258.         CANAR = CMR;CANDR = 0x04;
  259.         // 等待can发送完成
  260.         CANAR = SR;while(CANDR & 0x04);
  261. }
  262. /* can接收中断 */
  263. void CAN1_ISR_Handler (void) interrupt CAN1_VECTOR
  264. {
  265.         u8 isr;
  266.         u8 store;
  267.         u8 arTemp;
  268.         can_context_t cont;

  270.         arTemp = CANAR;                                                     //先CANAR现场保存，避免主循环里写完 CANAR 后产生中断，在中断里修改了 CANAR 内容
  271.         store = AUXR2;                                                      //后AUXR2现场保存
  272.                                                         
  273.         AUXR2 &= ~0x08;                                                                //选择CAN1模块
  274.         isr = CanReadReg(ISR);                                
  275.         CANAR = ISR;                                
  276.         CANDR = isr;                                                             //写1清除标志位        
  277.         if((isr & 0x08) == 0x08)                                          //RI
  278.         {
  279.                 // 存储接收到的数据
  280.                 cont.upid = CanReadStandardFrame(&(cont.cmd));
  281.                 can_queue_push(CAN1, &cont);
  282.                 // 清除中断标志
  283.                 CANAR = ISR;
  284.                 CANDR |= 0x08;
  285.         }

  287.         if((isr & 0x20) == 0x20)                                          //EWI
  288.         {
  289.                 CANAR = MR;
  290.                 CANDR &= ~0x04;                                                  //清除 Reset Mode, 从BUS-OFF状态退出
  291.                 CANAR = ISR;
  292.                 CANDR |= 0x20;                                                    //CLR FLAG
  293.         }
  294.         AUXR2 = store;                                                             //先AUXR2现场恢复
  295.         CANAR = arTemp;                                                            //后CANAR现场恢复
  296. }
复制代码

作者: 的花朵    时间: 2022-6-28 10:17
难道是不能在中断中做readFifo的操作？
作者: 的花朵    时间: 2022-6-28 10:17
难道是不能在中断中做readFifo的操作？
作者: STC庄伟    时间: 2022-6-28 16:25
http://www.stcmcudata.com/STC8F-DATASHEET/STC32G-SOFTWARE-LIB.zip        库也更新了，如果还是不行  请找陈工   
作者: STC庄伟    时间: 2022-6-28 16:41
http://www.stcmcudata.com/OpenSo ... DIP64-DEMO-CODE.ZIP            这里面是 普通的 C 语言直接操作 SFR的程序
作者: 的花朵    时间: 2022-6-28 17:10
STC庄伟 发表于 2022-6-28 16:25
http://www.stcmcudata.com/STC8F-DATASHEET/STC32G-SOFTWARE-LIB.zip        库也更新了，如果还是不行   ...

谢谢！，我研究一下
作者: 的花朵    时间: 2022-6-29 09:12
问题解决了，后面发现是TSG1,TSG2,BRP三个寄存器配置问题（自己写的算法分配了三个寄存器的值，虽然能通信，但是可能并不合理）
作者: 的花朵    时间: 2022-6-29 09:15
STC庄伟 发表于 2022-6-28 16:41
http://www.stcmcudata.com/OpenSource/STC32G12K128-LQFP64-DIP64-DEMO-CODE.ZIP            这里面是 普 ...

感谢！
作者: 内卷1234    时间: 2024-9-19 09:23
#include "STC32G.h"
#include "intrins.h"

typedef         unsigned char        u8;
typedef         unsigned int        u16;
typedef         unsigned long        u32;

#define MAIN_Fosc        24000000UL

/****************************** 用户定义宏 ***********************************/
//CAN总线波特率=Fclk/((1+(TSG1+1)+(TSG2+1))*(BRP+1)*2)
#define TSG1    2                //0~15
#define TSG2    1                //1~7 (TSG2 不能设置为0)
#define BRP     3                //0~63
//24000000/((1+3+2)*4*2)=500KHz

#define SJW     1                //重新同步跳跃宽度

//总线波特率100KHz以上设置为 0; 100KHz以下设置为 1
#define SAM     0                //总线电平采样次数： 0:采样1次; 1:采样3次

/*****************************************************************************/


/*************  本地常量声明    **************/

#define Timer0_Reload   (65536UL -(MAIN_Fosc / 1000))       //Timer 0 中断频率, 1000次/秒

#define        STANDARD_FRAME   0     //帧格式：标准帧
#define        EXTENDED_FRAME   1     //帧格式：扩展帧

/*************  本地变量声明    **************/

typedef struct
{
        u8        DLC:4;          //数据长度, bit0~bit3
        u8        :2;             //空数据, bit4~bit5
        u8        RTR:1;          //帧类型, bit6
        u8        FF:1;           //帧格式, bit7
        u32        ID;             //CAN ID
        u8        DataBuffer[8];  //数据缓存
}CAN_DataDef;

CAN_DataDef CAN1_Tx;
CAN_DataDef CAN1_Rx[8];

bit B_CanRead;      //CAN 收到数据标志
bit B_1ms;          //1ms标志
u16 msecond;

/*************  本地函数声明    **************/
void CANInit();
u8 CanReadReg(u8 addr);
u8 CanReadMsg(CAN_DataDef *CAN);
void CanSendMsg(CAN_DataDef *CAN);

/********************* 主函数 *************************/
void main(void)
{
        u8 sr,i,n;

    WTST = 0;  //设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快
    EAXFR = 1; //扩展寄存器(XFR)访问使能
    CKCON = 0; //提高访问XRAM速度

    P0M1 = 0x30;   P0M0 = 0x30;   //设置P0.4、P0.5为漏极开路(实验箱加了上拉电阻到3.3V)
    P1M1 = 0x32;   P1M0 = 0x32;   //设置P1.1、P1.4、P1.5为漏极开路(实验箱加了上拉电阻到3.3V), P1.1在PWM当DAC电路通过电阻串联到P2.3
    P2M1 = 0x3c;   P2M0 = 0x3c;   //设置P2.2~P2.5为漏极开路(实验箱加了上拉电阻到3.3V)
    P3M1 = 0x50;   P3M0 = 0x50;   //设置P3.4、P3.6为漏极开路(实验箱加了上拉电阻到3.3V)
    P4M1 = 0x3c;   P4M0 = 0x3c;   //设置P4.2~P4.5为漏极开路(实验箱加了上拉电阻到3.3V)
    P5M1 = 0x0c;   P5M0 = 0x0c;   //设置P5.2、P5.3为漏极开路(实验箱加了上拉电阻到3.3V)
    P6M1 = 0xff;   P6M0 = 0xff;   //设置为漏极开路(实验箱加了上拉电阻到3.3V)
    P7M1 = 0x00;   P7M0 = 0x00;   //设置为准双向口

        AUXR = 0x80;    //Timer0 set as 1T, 16 bits timer auto-reload,
        TH0 = (u8)(Timer0_Reload / 256);
        TL0 = (u8)(Timer0_Reload % 256);
        ET0 = 1;    //Timer0 interrupt enable
        TR0 = 1;    //Tiner0 run

        CANInit();
       
        EA = 1;                 //打开总中断

        CAN1_Tx.FF = EXTENDED_FRAME;    //扩展帧
        CAN1_Tx.RTR = 0;                //0：数据帧，1：远程帧
        CAN1_Tx.DLC = 0x08;             //数据长度
        CAN1_Tx.ID = 0x01234567;        //CAN ID
        CAN1_Tx.DataBuffer[0] = 0x21;   //数据内容
        CAN1_Tx.DataBuffer[1] = 0x22;
        CAN1_Tx.DataBuffer[2] = 0x23;
        CAN1_Tx.DataBuffer[3] = 0x24;
        CAN1_Tx.DataBuffer[4] = 0x25;
        CAN1_Tx.DataBuffer[5] = 0x26;
        CAN1_Tx.DataBuffer[6] = 0x27;
        CAN1_Tx.DataBuffer[7] = 0x28;
       
        while(1)
        {
                if(B_1ms)   //1ms到
                {
                        B_1ms = 0;
                        if(++msecond >= 1000)   //1秒到
                        {
                                msecond = 0;
                                sr = CanReadReg(SR);

                                if(sr & 0x01)                //判断是否有 BS:BUS-OFF状态
                                {
                                        CANAR = MR;
                                        CANDR &= ~0x04;  //清除 Reset Mode, 从BUS-OFF状态退出
                                }
                                else
                                {
                    CanSendMsg(&CAN1_Tx);   //发送一帧数据
                                }
                        }
                }

                if(B_CanRead)
                {
                        B_CanRead = 0;
                       
            n = CanReadMsg(CAN1_Rx);    //读取接收内容
            if(n>0)
            {
                for(i=0;i<n;i++)
                {
                    CanSendMsg(&CAN1_Rx[i]);  //CAN总线原样返回
                }
            }
                }
        }
}


/********************** Timer0 1ms中断函数 ************************/
void timer0 (void) interrupt 1
{
    B_1ms = 1;      //1ms标志
}

//========================================================================
// 函数: u8 ReadReg(u8 addr)
// 描述: CAN功能寄存器读取函数。
// 参数: CAN功能寄存器地址.
// 返回: CAN功能寄存器数据.
// 版本: VER1.0
// 日期: 2020-11-16
// 备注:
//========================================================================
u8 CanReadReg(u8 addr)
{
        u8 dat;
        CANAR = addr;
        dat = CANDR;
        return dat;
}

//========================================================================
// 函数: void WriteReg(u8 addr, u8 dat)
// 描述: CAN功能寄存器配置函数。
// 参数: CAN功能寄存器地址, CAN功能寄存器数据.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-16
// 备注:
//========================================================================
void CanWriteReg(u8 addr, u8 dat)
{
        CANAR = addr;
        CANDR = dat;
}

//========================================================================
// 函数: void CanReadFifo(CAN_DataDef *CANx)
// 描述: 读取CAN缓冲区数据函数。
// 参数: *CANx: 存放CAN总线读取数据.
// 返回: none.
// 版本: VER2.0
// 日期: 2023-01-31
// 备注:
//========================================================================
void CanReadFifo(CAN_DataDef *CAN)
{
    u8 i;
    u8 pdat[5];
    u8 RX_Index=0;

    pdat[0] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));

    if(pdat[0] & 0x80)  //判断是标准帧还是扩展帧
    {
        pdat[1] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));   //扩展帧ID占4个字节
        pdat[2] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));
        pdat[3] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));
        pdat[4] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));
        CAN->ID = (((u32)pdat[1] << 24) + ((u32)pdat[2] << 16) + ((u32)pdat[3] << 8) + pdat[4]) >> 3;
    }
    else
    {
        pdat[1] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));   //标准帧ID占2个字节
        pdat[2] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));
        CAN->ID = ((pdat[1] << 8) + pdat[2]) >> 5;
    }
   
    CAN->FF = pdat[0] >> 7;     //帧格式
    CAN->RTR = pdat[0] >> 6;    //帧类型
    CAN->DLC = pdat[0];         //数据长度

    for(i=0;((i<CAN->DLC) && (i<8));i++)        //读取数据长度为len，最多不超过8
    {
        CAN->DataBuffer[i] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));   //读取有效数据
    }
    while(RX_Index&3)   //判断已读数据长度是否4的整数倍
    {
        CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));  //读取填充数据，一帧数据占据4的整数倍缓冲区空间，不足补0
    }
}

//========================================================================
// 函数: u8 CanReadMsg(void)
// 描述: CAN接收数据函数。
// 参数: *CANx: 存放CAN总线读取数据..
// 返回: 帧个数.
// 版本: VER2.0
// 日期: 2023-01-31
// 备注:
//========================================================================
u8 CanReadMsg(CAN_DataDef *CAN)
{
    u8 i;
    u8 n=0;

    do{
        CanReadFifo(&CAN[n++]);  //读取接收缓冲区数据
        i = CanReadReg(SR);
    }while(i&0x80);     //判断接收缓冲区里是否还有数据，有的话继续读取

    return n;   //返回帧个数
}

//========================================================================
// 函数: void CanSendMsg(CAN_DataDef *CAN)
// 描述: CAN发送标准帧函数。
// 参数: *CANx: 存放CAN总线发送数据..
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 备注:
//========================================================================
void CanSendMsg(CAN_DataDef *CAN)
{
        u32 CanID;
    u8 RX_Index,i;

    if(CAN->FF)     //判断是否扩展帧
    {
        CanID = CAN->ID << 3;
        CanWriteReg(TX_BUF0,CAN->DLC|((u8)CAN->RTR<<6)|0x80);        //bit7: 标准帧(0)/扩展帧(1), bit6: 数据帧(0)/远程帧(1), bit3~bit0: 数据长度(DLC)
        CanWriteReg(TX_BUF1,(u8)(CanID>>24));
        CanWriteReg(TX_BUF2,(u8)(CanID>>16));
        CanWriteReg(TX_BUF3,(u8)(CanID>>8));

        CanWriteReg(TX_BUF0,(u8)CanID);

        RX_Index = 1;
        for(i=0;((i<CAN->DLC) && (i<8));i++)        //数据长度为DLC，最多不超过8
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),CAN->DataBuffer[i]);   //写入有效数据
        }
        while(RX_Index&3)   //判断已读数据长度是否4的整数倍
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),0x00);  //写入填充数据，一帧数据占据4的整数倍缓冲区空间，不足补0
        }
    }
    else    //发送标准帧
    {
        CanID = (u16)(CAN->ID << 5);
        CanWriteReg(TX_BUF0,CAN->DLC|((u8)CAN->RTR<<6));  //bit7: 标准帧(0)/扩展帧(1), bit6: 数据帧(0)/远程帧(1), bit3~bit0: 数据长度(DLC)
        CanWriteReg(TX_BUF1,(u8)(CanID>>8));
        CanWriteReg(TX_BUF2,(u8)CanID);

        RX_Index = 3;
        for(i=0;((i<CAN->DLC) && (i<8));i++)        //数据长度为DLC，最多不超过8
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),CAN->DataBuffer[i]);   //写入有效数据
        }
        while(RX_Index&3)   //判断已读数据长度是否4的整数倍
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),0x00);  //写入填充数据，一帧数据占据4的整数倍缓冲区空间，不足补0
        }
    }
        CanWriteReg(CMR ,0x04);                //发起一次帧传输
}

//========================================================================
// 函数: void CANSetBaudrate()
// 描述: CAN总线波特率设置函数。
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 备注:
//========================================================================
void CANSetBaudrate()
{
        CanWriteReg(BTR0,(SJW << 6) + BRP);
        CanWriteReg(BTR1,(SAM << 7) + (TSG2 << 4) + TSG1);
}

//========================================================================
// 函数: void CANInit()
// 描述: CAN初始化函数。
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 备注:
//========================================================================
void CANInit()
{
        CANEN = 1;          //CAN1模块使能
        CanWriteReg(MR  ,0x05);  //使能 Reset Mode, 采用单滤波设置

        CANSetBaudrate();        //设置波特率
       
        //设置过滤ID为：xxF8xxxx 的帧才接收
//        CanWriteReg(ACR0,0x07);                //总线验收代码寄存器
//        CanWriteReg(ACR1,0xc0);
//        CanWriteReg(ACR2,0x00);
//        CanWriteReg(ACR3,0x00);
//        CanWriteReg(AMR0,0xF8);                //总线验收屏蔽寄存器
//        CanWriteReg(AMR1,0x07);
//        CanWriteReg(AMR2,0xFF);
//        CanWriteReg(AMR3,0xFF);

        //取消过滤ID，所有帧都接收
        CanWriteReg(ACR0,0x00);                //总线验收代码寄存器
        CanWriteReg(ACR1,0x00);
        CanWriteReg(ACR2,0x00);
        CanWriteReg(ACR3,0x00);
        CanWriteReg(AMR0,0xFF);                //总线验收屏蔽寄存器
        CanWriteReg(AMR1,0xFF);
        CanWriteReg(AMR2,0xFF);
        CanWriteReg(AMR3,0xFF);

        CanWriteReg(IMR ,0xff);                //中断寄存器
        CanWriteReg(ISR ,0xff);                //清中断标志
        CanWriteReg(MR  ,0x01);                //退出 Reset Mode, 采用单滤波设置(设置过滤器后注意选择滤波模式)
//        CanWriteReg(MR  ,0x00);                //退出 Reset Mode, 采用双滤波设置(设置过滤器后注意选择滤波模式)

        P_SW1 = (P_SW1 & ~(3<<4)) | (0<<4); //端口切换(CAN_Rx,CAN_Tx) 0x00:P0.0,P0.1  0x10:P5.0,P5.1  0x20:P4.2,P4.5  0x30:P7.0,P7.1
        CANICR = 0x02;                //CAN中断使能
}

//========================================================================
// 函数: void CANBUS_Interrupt(void) interrupt CAN1_VECTOR
// 描述: CAN总线中断函数。
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 备注:
//========================================================================
void CANBUS_Interrupt(void) interrupt CAN1_VECTOR
{
        u8 isr;
        u8 arTemp;
        arTemp = CANAR;     //CANAR现场保存，避免主循环里写完 CANAR 后产生中断，在中断里修改了 CANAR 内容
       
        isr = CanReadReg(ISR);
        if((isr & 0x04) == 0x04)  //TI
    {
                CANAR = ISR;
                CANDR = 0x04;    //CLR FLAG
    }       
        if((isr & 0x08) == 0x08)  //RI
    {
                CANAR = ISR;
                CANDR = 0x08;    //CLR FLAG
       
                B_CanRead = 1;
    }

        if((isr & 0x40) == 0x40)  //ALI
    {
                CANAR = ISR;
                CANDR = 0x40;    //CLR FLAG
    }       

        if((isr & 0x20) == 0x20)  //EWI
    {
                CANAR = ISR;
                CANDR = 0x20;    //CLR FLAG
    }       

        if((isr & 0x10) == 0x10)  //EPI
    {
                CANAR = ISR;
                CANDR = 0x10;    //CLR FLAG
    }       

        if((isr & 0x02) == 0x02)  //BEI
    {
                CANAR = ISR;
                CANDR = 0x02;    //CLR FLAG
    }       

        if((isr & 0x01) == 0x01)  //DOI
    {
                CANAR = ISR;
                CANDR = 0x01;    //CLR FLAG
    }       

        CANAR = arTemp;    //CANAR现场恢复
}

试试这个，感觉你的中断没配好



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1