CAN接收数据有问题，求教排查思路

还在*** · 发表于 6 天前

本人测试两部MCU是32G12K64的板子，硬件看原理图应该没问题，但是没用CAN转USB测试过。
代码是官网上给的例程，PSW_1寄存器接口没问题，波特率是一致的，滤波器全通。
现象应该是2发送数据则P20LED开关，1接收数据则P27LED开关，但是并没有看到STC1LED的现象。
如果我代码写两台都发的话，就会出现两台STC同时发的LED闪烁，说明根本没有管CAN总线空不空闲。

第一台机收STC1，其代码如下
#include "..\..\comm\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 15             //0~15
#define TSG2 6             //1~7 (TSG2 不能设置为0)
#define BRP    1             //0~63                                     250khz
//24000000/((1+3+2)*4*2)=500KHz

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

//总线波特率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_CanSend;    //CAN 发送完成标志
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  delay_ms(u8 ms);

/********************* 主函数 *************************/
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 = 0x30; // 假设P7.0对应bit4，P7.1对应bit5（根据数据手册调整）
P7M0 = 0x30;
P40=0;
      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 = STANDARD_FRAME; //标准帧
      CAN1_Tx.RTR = 0;             //0：数据帧，1：远程帧
      CAN1_Tx.DLC = 0x08;          //数据长度
      CAN1_Tx.ID = 0x0345;          //CAN ID
      CAN1_Tx.DataBuffer[0] = 0x11; //数据内容
      CAN1_Tx.DataBuffer[1] = 0x12;
      CAN1_Tx.DataBuffer[2] = 0x13;
      CAN1_Tx.DataBuffer[3] = 0x14;
      CAN1_Tx.DataBuffer[4] = 0x15;
      CAN1_Tx.DataBuffer[5] = 0x16;
      CAN1_Tx.DataBuffer[6] = 0x17;
      CAN1_Tx.DataBuffer[7] = 0x18;

B_CanSend = 0;
      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); //发送一帧数据
//                                     P21=0;
//                               delay_ms(250);
//                                     P21=1;
//                               }
//                      }
//             }

            if(B_CanRead)
            {
                     B_CanRead = 0;

         n = CanReadMsg(CAN1_Rx); //读取接收内容
//             P27=0;
//                               delay_ms(250);
//                                     P27=1;
                                    P27 = ~P27;
//          if(n>0)
//          {
//             for(i=0;i<n;i++)
//             {
//                   CanSendMsg(&CAN1_Rx);  //CAN总线原样返回
//                                                                               P25=0;
//                               delay_ms(250);
//                                     P25=1;
//             }
//          }
            }
      }
}

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

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

//========================================================================
// 函数: void CanWriteReg(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 = 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);    //判断接收缓冲区里是否还有数据，有的话继续读取
CanWriteReg(CMR, 0x04); // 新增：释放接收缓冲区命令
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;

i = 200;
while((--i) && (B_CanSend));  //等待上次发送完成

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); //写入有效数据
      }
      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); //写入有效数据
      }
      while(RX_Index&3) //判断已读数据长度是否4的整数倍
      {
         CanWriteReg((u8)(TX_BUF0 + (RX_Index++&3)),0x00);  //写入填充数据，一帧数据占据4的整数倍缓冲区空间，不足补0
      }
}
      CanWriteReg(CMR ,0x04);             //发起一次帧传输
B_CanSend = 1;    //设置发送忙标志
}

//========================================================================
// 函数: 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模块使能
CANSEL = 0; //选择CAN1模块
/*端口切换(CAN_Rx,CAN_Tx) 0x00:P0.0,P0.1 0x10:P5.0,P5.1 0x20:P4.2,P4.5 0x30:P7.0,P7.1*/
P_SW1 = (P_SW1 & ~(3 << 4)) | (3 << 4);  // 先清零 bit4~bit5，再设置为 3（0x30）

//CAN2EN = 1; //CAN2模块使能
//CANSEL = 1; //选择CAN2模块
//端口切换(CAN_Rx,CAN_Tx) 0x00:P0.2,P0.3 0x01:P5.2,P5.3 0x02:P4.6,P4.7 0x03:P7.2,P7.3
//P_SW3 = (P_SW3 & ~(3)) | (0);

CanWriteReg(MR, 0x04); //使能Reset Mode
CANSetBaudrate(); //设置波特率

//使用单滤波过滤器，只接收ID=0x07fe的报文
//CanWriteReg(ACR0,0xff); //总线验收代码寄存器
//CanWriteReg(ACR1,0xc0);
//CanWriteReg(ACR2,0x00);
//CanWriteReg(ACR3,0x00);
//CanWriteReg(AMR0,0x00); //总线验收屏蔽寄存器
//CanWriteReg(AMR1,0x0F);
//CanWriteReg(AMR2,0xFF);
//CanWriteReg(AMR3,0xFF);

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); //清中断标志
/*退出Reset Mode，采用单滤波设置(设置过滤器后注意选择滤波模式)*/
CanWriteReg(MR,0x01);
CANICR = 0x02; //CAN中断使能
}

//========================================================================
// 函数: void CANBUS_Interrupt(void) interrupt CAN_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

      B_CanSend = 0;
      }
      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现场恢复
}
void  delay_ms(u8 ms)
{
   u16 i;
   do{
      i = MAIN_Fosc / 6000;
      while(--i);
   }while(--ms);
}

STC2其他都一致，主函数如下：
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 = 0x30; // 假设P7.0对应bit4，P7.1对应bit5（根据数据手册调整）
P7M0 = 0x30;
P40=0;
      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 = STANDARD_FRAME; //标准帧
      CAN1_Tx.RTR = 0;             //0：数据帧，1：远程帧
      CAN1_Tx.DLC = 0x08;          //数据长度
      CAN1_Tx.ID = 0x0789;          //CAN ID
      CAN1_Tx.DataBuffer[0] = 0x11; //数据内容
      CAN1_Tx.DataBuffer[1] = 0x12;
      CAN1_Tx.DataBuffer[2] = 0x13;
      CAN1_Tx.DataBuffer[3] = 0x14;
      CAN1_Tx.DataBuffer[4] = 0x15;
      CAN1_Tx.DataBuffer[5] = 0x16;
      CAN1_Tx.DataBuffer[6] = 0x17;
      CAN1_Tx.DataBuffer[7] = 0x18;

B_CanSend = 0;
      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); //发送一帧数据

                                    P20 = ~P20;
                              }
                     }
            }

}
}

国芯人*** · 发表于 6 天前

针对您描述的STC32G系列MCU CAN通信故障现象，建议按照以下系统性排查思路进行分析：

一、硬件层验证
1. 物理层验证
测量CANH与CANL间差分电阻（应≈60Ω，两终端各接120Ω电阻）
用示波器观察总线波形：发送时应有明显差分电平跳变（显性电平约2V，隐性约0V）
检查收发器供电：VCC电压是否稳定（建议5V±5%），VIO是否与MCU电平匹配
验证收发器使能引脚：TXD电平是否正常（发送时应为显性电平）

2. 拓扑结构验证
双节点系统必须配置两个终端电阻（每个电阻120Ω±1%）
总线长度超过0.5米时需采用双绞线布线
检查接线极性：确保CANH与CANH直连，CANL与CANL直连

二、协议层分析
1. 波特率配置验证
请核对实际配置参数：
波特率 = Fclk / [(1 + TSG1 + TSG2)  (BRP + 1)  2]
按给定参数计算：
24MHz / [(1+15+6)(1+1)2] = 24,000,000 / (224) = 272.727kHz
与注释中250kHz存在偏差，建议使用标准波特率参数组合。

2. 工作模式配置
检查初始化流程是否包含：
CANMOD |= 0x01; // 进入复位模式
// 配置时序参数...
CANMOD &= ~0x01; // 退出复位模式

3. 滤波器配置验证
全通滤波器推荐配置：
CANCDR = 0x08;    // 双滤波器模式
CANADR = 0x00;    // 选择验收码寄存器
CANDAT = 0x0000; // 验收码设为全0
CANADR = 0x02;    // 选择屏蔽码寄存器
CANDAT = 0xFFFF; // 屏蔽码设为全1

三、软件逻辑诊断
1. 接收中断服务程序检查
需确保以下关键操作：
void CANISR() interrupt 19
{
if(CANSTAT & 0x01)  // 接收中断标志
{
      P27 = ~P27;    // LED翻转
      CANCMR = 0x04;  // 释放接收缓冲区
      CANSTAT &= ~0x01; // 清除中断标志
}
}

2. 总线状态监控
添加总线错误检测：
if(CANSTAT & 0x80) {
// 总线关闭状态处理
CANCMR = 0x1C;    // 清除错误计数器
}

3. 发送冲突处理
修改发送函数：
bit CANTransmit(u8 msg)
{
if(!(CANSTAT & 0x04)) return 0; // 检测发送缓冲器状态
// 填充数据到发送缓冲区...
CANCMR = 0x01;    // 启动发送
return 1;
}

四、调试建议
1. 使用回环模式自检
配置CANMOD |= 0x02; 进入自环模式，验证自发自收功能

2. 寄存器级诊断
监控关键寄存器状态：
CANSTAT：查看LEC错误码（Bit5-7）
CANTEC/CANREC：错误计数器值
CANIR：中断请求状态

3. 信号质量测试
在总线空闲时测量：
CANH对地电压：2.5V±0.5V
CANL对地电压：2.5V±0.5V
差分电压：应小于50mV

建议补充测试：将两台设备的CANH与CANL直接短接（无需收发器），通过数字IO模拟标准帧（11位ID），验证最简通信链路是否正常。此方法可隔离收发器故障因素。

通过上述分层排查，通常可定位到硬件连接、时序配置或中断处理等层面的问题。对于缺乏CAN分析仪的情况，建议重点观察总线错误标志位和错误计数器的变化趋势，这对判断物理层故障具有重要参考价值。

[本文内容由国芯人工智能辅助生成，仅供参考]

王*** · 发表于 6 天前

can收发测试需要注意的是，外部的电平转换电路需要焊接，内部仅仅是一个can协议控制，如果直接接上并不能通信。
其次，发送函数中并没有处理两个同时发的情况，这个需要自行结合仲裁状态进行判断
截图202505041649119214.jpg

最后，请先使用官方的测试电路和测试程序通过，然后再进行改动比较好，可以省去寻找问题的麻烦

还在*** · 发表于 6 天前

王*** 发表于 2025-5-4 16:50
can收发测试需要注意的是，外部的电平转换电路需要焊接，内部仅仅是一个can协议控制，如果直接接上并不能通 ...

首先我是焊接了TJA1050的收发器电路，我觉得没问题
其次，同时发的话应该根据ID号进行自动仲裁吗？同时发说明CAN总线没起作用？
最后，我这个程序是从官网上的例程改编的，基本上变动不大。还有测试电路，你指的是CAN转USB来转到电脑来测试？

王*** · 发表于 5 天前

还在*** 发表于 2025-5-4 20:21
首先我是焊接了TJA1050的收发器电路，我觉得没问题
其次，同时发的话应该根据ID号进行自动仲裁吗？同时发 ...

嗯，可以先使用CAN转USB来测试
同时发并不一定说明CAN总线没起作用，因为CAN报文发送挺快的，可能一个发送的时候另一个已经发送完成了，所以他们可以同时发送并不能看出来什么。

		自动登录	找回密码
密码			立即注册

CAN接收数据有问题，求教排查思路

点评