標題: STC32G12K128單片機的CAN連續(xù)收發(fā)問題 [打印本頁]
作者: 的花朵    時間: 2022-6-27 18:41
標題: STC32G12K128單片機的CAN連續(xù)收發(fā)問題
如題，目前在STC32G單片機上做開發(fā)，要用到CAN總線，按照例程配置了一下，測試單次收發(fā)沒有問題，但是連續(xù)收發(fā)單片機總會收多或收少，少的時候能少幾十幀，多的時候也能多幾十幀，應(yīng)該是我的配置問題，求大佬指點哇，我的配置如下:
  1. #include "can.h"
  2. #include "config.h"
  3. #include "STC32G_NVIC.h"

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

  8. // can 設(shè)備句柄
  9. static can_t can1 = { 0 };
  10. static can_t can2 = { 0 };
  11. /* 初始化can設(shè)備 */
  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;                                                //結(jié)構(gòu)定義
  17.         GPIO_InitTypeDef        GPIO_InitStructure;                                        //結(jié)構(gòu)定義
  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;                                                        //總線電平采樣次數(shù)  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 不能設(shè)置為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 不能設(shè)置為0)        
  75.         }
  76.         CAN_InitStructure.CAN_BRP    = tmp_brp - 1;                        //波特率分頻系數(shù)    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.         // 存在緊急命令時優(yōu)先吐出
  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.                         // 地址上有內(nèi)容
  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為下次數(shù)據(jù)填充做準備
  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.         // 優(yōu)先寫入緊急命令
  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.                         // 地址上已有內(nèi)容，返回隊列已滿
  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. /* 發(fā)送標準幀 */
  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發(fā)送完成
  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現(xiàn)場保存，避免主循環(huán)里寫完 CANAR 后產(chǎn)生中斷，在中斷里修改了 CANAR 內(nèi)容
  271.         store = AUXR2;                                                      //后AUXR2現(xiàn)場保存
  272.                                                         
  273.         AUXR2 &= ~0x08;                                                                //選擇CAN1模塊
  274.         isr = CanReadReg(ISR);                                
  275.         CANAR = ISR;                                
  276.         CANDR = isr;                                                             //寫1清除標志位        
  277.         if((isr & 0x08) == 0x08)                                          //RI
  278.         {
  279.                 // 存儲接收到的數(shù)據(jù)
  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狀態(tài)退出
  291.                 CANAR = ISR;
  292.                 CANDR |= 0x20;                                                    //CLR FLAG
  293.         }
  294.         AUXR2 = store;                                                             //先AUXR2現(xiàn)場恢復(fù)
  295.         CANAR = arTemp;                                                            //后CANAR現(xiàn)場恢復(fù)
  296. }
復(fù)制代碼

作者: 的花朵    時間: 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莊偉 發(fā)表于 2022-6-28 16:25
http://www.stcmcudata.com/STC8F-DATASHEET/STC32G-SOFTWARE-LIB.zip        庫也更新了，如果還是不行   ...

謝謝！，我研究一下
作者: 的花朵    時間: 2022-6-29 09:12
問題解決了，后面發(fā)現(xiàn)是TSG1,TSG2,BRP三個寄存器配置問題（自己寫的算法分配了三個寄存器的值，雖然能通信，但是可能并不合理）
作者: 的花朵    時間: 2022-6-29 09:15
STC莊偉 發(fā)表于 2022-6-28 16:41
http://www.stcmcudata.com/OpenSource/STC32G12K128-LQFP64-DIP64-DEMO-CODE.ZIP            這里面是 普 ...

感謝！
作者: 內(nèi)卷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 不能設(shè)置為0)
#define BRP     3                //0~63
//24000000/((1+3+2)*4*2)=500KHz

#define SJW     1                //重新同步跳躍寬度

//總線波特率100KHz以上設(shè)置為 0; 100KHz以下設(shè)置為 1
#define SAM     0                //總線電平采樣次數(shù)： 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;          //數(shù)據(jù)長度, bit0~bit3
        u8        :2;             //空數(shù)據(jù), bit4~bit5
        u8        RTR:1;          //幀類型, bit6
        u8        FF:1;           //幀格式, bit7
        u32        ID;             //CAN ID
        u8        DataBuffer[8];  //數(shù)據(jù)緩存
}CAN_DataDef;

CAN_DataDef CAN1_Tx;
CAN_DataDef CAN1_Rx[8];

bit B_CanRead;      //CAN 收到數(shù)據(jù)標志
bit B_1ms;          //1ms標志
u16 msecond;

/*************  本地函數(shù)聲明    **************/
void CANInit();
u8 CanReadReg(u8 addr);
u8 CanReadMsg(CAN_DataDef *CAN);
void CanSendMsg(CAN_DataDef *CAN);

/********************* 主函數(shù) *************************/
void main(void)
{
        u8 sr,i,n;

    WTST = 0;  //設(shè)置程序指令延時參數(shù)，賦值為0可將CPU執(zhí)行指令的速度設(shè)置為最快
    EAXFR = 1; //擴展寄存器(XFR)訪問使能
    CKCON = 0; //提高訪問XRAM速度

    P0M1 = 0x30;   P0M0 = 0x30;   //設(shè)置P0.4、P0.5為漏極開路(實驗箱加了上拉電阻到3.3V)
    P1M1 = 0x32;   P1M0 = 0x32;   //設(shè)置P1.1、P1.4、P1.5為漏極開路(實驗箱加了上拉電阻到3.3V), P1.1在PWM當DAC電路通過電阻串聯(lián)到P2.3
    P2M1 = 0x3c;   P2M0 = 0x3c;   //設(shè)置P2.2~P2.5為漏極開路(實驗箱加了上拉電阻到3.3V)
    P3M1 = 0x50;   P3M0 = 0x50;   //設(shè)置P3.4、P3.6為漏極開路(實驗箱加了上拉電阻到3.3V)
    P4M1 = 0x3c;   P4M0 = 0x3c;   //設(shè)置P4.2~P4.5為漏極開路(實驗箱加了上拉電阻到3.3V)
    P5M1 = 0x0c;   P5M0 = 0x0c;   //設(shè)置P5.2、P5.3為漏極開路(實驗箱加了上拉電阻到3.3V)
    P6M1 = 0xff;   P6M0 = 0xff;   //設(shè)置為漏極開路(實驗箱加了上拉電阻到3.3V)
    P7M1 = 0x00;   P7M0 = 0x00;   //設(shè)置為準雙向口

        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：數(shù)據(jù)幀，1：遠程幀
        CAN1_Tx.DLC = 0x08;             //數(shù)據(jù)長度
        CAN1_Tx.ID = 0x01234567;        //CAN ID
        CAN1_Tx.DataBuffer[0] = 0x21;   //數(shù)據(jù)內(nèi)容
        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狀態(tài)
                                {
                                        CANAR = MR;
                                        CANDR &= ~0x04;  //清除 Reset Mode, 從BUS-OFF狀態(tài)退出
                                }
                                else
                                {
                    CanSendMsg(&CAN1_Tx);   //發(fā)送一幀數(shù)據(jù)
                                }
                        }
                }

                if(B_CanRead)
                {
                        B_CanRead = 0;
                       
            n = CanReadMsg(CAN1_Rx);    //讀取接收內(nèi)容
            if(n>0)
            {
                for(i=0;i<n;i++)
                {
                    CanSendMsg(&CAN1_Rx[i]);  //CAN總線原樣返回
                }
            }
                }
        }
}


/********************** Timer0 1ms中斷函數(shù) ************************/
void timer0 (void) interrupt 1
{
    B_1ms = 1;      //1ms標志
}

//========================================================================
// 函數(shù): u8 ReadReg(u8 addr)
// 描述: CAN功能寄存器讀取函數(shù)。
// 參數(shù): CAN功能寄存器地址.
// 返回: CAN功能寄存器數(shù)據(jù).
// 版本: VER1.0
// 日期: 2020-11-16
// 備注:
//========================================================================
u8 CanReadReg(u8 addr)
{
        u8 dat;
        CANAR = addr;
        dat = CANDR;
        return dat;
}

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

//========================================================================
// 函數(shù): void CanReadFifo(CAN_DataDef *CANx)
// 描述: 讀取CAN緩沖區(qū)數(shù)據(jù)函數(shù)。
// 參數(shù): *CANx: 存放CAN總線讀取數(shù)據(jù).
// 返回: 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個字節(jié)
        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個字節(jié)
        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];         //數(shù)據(jù)長度

    for(i=0;((i<CAN->DLC) && (i<8));i++)        //讀取數(shù)據(jù)長度為len，最多不超過8
    {
        CAN->DataBuffer[i] = CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));   //讀取有效數(shù)據(jù)
    }
    while(RX_Index&3)   //判斷已讀數(shù)據(jù)長度是否4的整數(shù)倍
    {
        CanReadReg((u8)(RX_BUF0 + (RX_Index++&3)));  //讀取填充數(shù)據(jù)，一幀數(shù)據(jù)占據(jù)4的整數(shù)倍緩沖區(qū)空間，不足補0
    }
}

//========================================================================
// 函數(shù): u8 CanReadMsg(void)
// 描述: CAN接收數(shù)據(jù)函數(shù)。
// 參數(shù): *CANx: 存放CAN總線讀取數(shù)據(jù)..
// 返回: 幀個數(shù).
// 版本: VER2.0
// 日期: 2023-01-31
// 備注:
//========================================================================
u8 CanReadMsg(CAN_DataDef *CAN)
{
    u8 i;
    u8 n=0;

    do{
        CanReadFifo(&CAN[n++]);  //讀取接收緩沖區(qū)數(shù)據(jù)
        i = CanReadReg(SR);
    }while(i&0x80);     //判斷接收緩沖區(qū)里是否還有數(shù)據(jù)，有的話繼續(xù)讀取

    return n;   //返回幀個數(shù)
}

//========================================================================
// 函數(shù): void CanSendMsg(CAN_DataDef *CAN)
// 描述: CAN發(fā)送標準幀函數(shù)。
// 參數(shù): *CANx: 存放CAN總線發(fā)送數(shù)據(jù)..
// 返回: 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: 數(shù)據(jù)幀(0)/遠程幀(1), bit3~bit0: 數(shù)據(jù)長度(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++)        //數(shù)據(jù)長度為DLC，最多不超過8
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),CAN->DataBuffer[i]);   //寫入有效數(shù)據(jù)
        }
        while(RX_Index&3)   //判斷已讀數(shù)據(jù)長度是否4的整數(shù)倍
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),0x00);  //寫入填充數(shù)據(jù)，一幀數(shù)據(jù)占據(jù)4的整數(shù)倍緩沖區(qū)空間，不足補0
        }
    }
    else    //發(fā)送標準幀
    {
        CanID = (u16)(CAN->ID << 5);
        CanWriteReg(TX_BUF0,CAN->DLC|((u8)CAN->RTR<<6));  //bit7: 標準幀(0)/擴展幀(1), bit6: 數(shù)據(jù)幀(0)/遠程幀(1), bit3~bit0: 數(shù)據(jù)長度(DLC)
        CanWriteReg(TX_BUF1,(u8)(CanID>>8));
        CanWriteReg(TX_BUF2,(u8)CanID);

        RX_Index = 3;
        for(i=0;((i<CAN->DLC) && (i<8));i++)        //數(shù)據(jù)長度為DLC，最多不超過8
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),CAN->DataBuffer[i]);   //寫入有效數(shù)據(jù)
        }
        while(RX_Index&3)   //判斷已讀數(shù)據(jù)長度是否4的整數(shù)倍
        {
            CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),0x00);  //寫入填充數(shù)據(jù)，一幀數(shù)據(jù)占據(jù)4的整數(shù)倍緩沖區(qū)空間，不足補0
        }
    }
        CanWriteReg(CMR ,0x04);                //發(fā)起一次幀傳輸
}

//========================================================================
// 函數(shù): void CANSetBaudrate()
// 描述: CAN總線波特率設(shè)置函數(shù)。
// 參數(shù): none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 備注:
//========================================================================
void CANSetBaudrate()
{
        CanWriteReg(BTR0,(SJW << 6) + BRP);
        CanWriteReg(BTR1,(SAM << 7) + (TSG2 << 4) + TSG1);
}

//========================================================================
// 函數(shù): void CANInit()
// 描述: CAN初始化函數(shù)。
// 參數(shù): none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 備注:
//========================================================================
void CANInit()
{
        CANEN = 1;          //CAN1模塊使能
        CanWriteReg(MR  ,0x05);  //使能 Reset Mode, 采用單濾波設(shè)置

        CANSetBaudrate();        //設(shè)置波特率
       
        //設(shè)置過濾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, 采用單濾波設(shè)置(設(shè)置過濾器后注意選擇濾波模式)
//        CanWriteReg(MR  ,0x00);                //退出 Reset Mode, 采用雙濾波設(shè)置(設(shè)置過濾器后注意選擇濾波模式)

        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中斷使能
}

//========================================================================
// 函數(shù): void CANBUS_Interrupt(void) interrupt CAN1_VECTOR
// 描述: CAN總線中斷函數(shù)。
// 參數(shù): none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-11-19
// 備注:
//========================================================================
void CANBUS_Interrupt(void) interrupt CAN1_VECTOR
{
        u8 isr;
        u8 arTemp;
        arTemp = CANAR;     //CANAR現(xiàn)場保存，避免主循環(huán)里寫完 CANAR 后產(chǎn)生中斷，在中斷里修改了 CANAR 內(nèi)容
       
        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現(xiàn)場恢復(fù)
}

試試這個，感覺你的中斷沒配好



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1