2812 Can发送邮箱无法置为自动应答模式

只看该作者 · 2013-9-5 14:59

  我的发送邮箱初始化程序如下，目的是初始化MB1为发送邮箱（自动应答），当接收到远程帧时自动发送具有相同标识符的数据帧到Can总线。
  查了很多资料，貌似只要 MD=0，RTR=0，AAM=1，就可以将邮箱设置为自动应答模式，但是调试了几天没成功，发帖请教，请论坛里的朋友们多多指教，在此感激不尽！

void
InitECan(void)
{
  struct ECAN_REGS ECanaShadow;
  //配置GPIO引脚工作在eCAN功能
  EALLOW;
  GpioMuxRegs.GPFMUX.bit.CANRXA_GPIOF7=1;
  GpioMuxRegs.GPFMUX.bit.CANTXA_GPIOF6=1;

  //配置eCAN的RX和TX分别为eCAN的接收和发送引脚
  ECanaShadow.CANTIOC.all = ECanaRegs.CANTIOC.all;
  ECanaShadow.CANTIOC.bit.TXFUNC = 1;
  ECanaRegs.CANTIOC.all = ECanaShadow.CANTIOC.all;

  ECanaShadow.CANRIOC.all = ECanaRegs.CANRIOC.all;
  ECanaShadow.CANRIOC.bit.RXFUNC = 1;
  ECanaRegs.CANRIOC.all = ECanaShadow.CANRIOC.all;
  EDIS;

  EALLOW;
  ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  //工作在非测试模式
  ECanaShadow.CANMC.bit.STM = 0;
  //工作在ecan模式
  ECanaShadow.CANMC.bit.SCB = 1;
  ECanaShadow.CANMC.bit.DBO = 1;
  ECanaShadow.CANMC.bit.ABO = 1;
  ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  EDIS;

  ECanaMboxes.MBOX0.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX1.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX2.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX3.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX4.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX5.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX6.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX7.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX8.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX9.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX10.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX11.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX12.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX13.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX14.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX15.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX16.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX17.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX18.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX19.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX20.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX21.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX22.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX23.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX24.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX25.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX26.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX27.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX28.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX29.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX30.MSGCTRL.all = 0x00000000;
  ECanaMboxes.MBOX31.MSGCTRL.all = 0x00000000;

  //清除所有的TA位
  ECanaRegs.CANTA.all = 0xFFFFFFFF;
  //清除所有的RMP位
  ECanaRegs.CANRMP.all = 0xFFFFFFFF;
  //清除所有的中断标志位
  ECanaRegs.CANGIF0.all = 0xFFFFFFFF;
  ECanaRegs.CANGIF1.all = 0xFFFFFFFF;

  //配置时钟参数
  EALLOW;
  ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  ECanaShadow.CANMC.bit.CCR = 1;
  ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  EDIS;

  do
  {
ECanaShadow.CANES.all = ECanaRegs.CANES.all;
  }
  while(ECanaShadow.CANES.bit.CCE != 1);

  EALLOW;
  ECanaRegs.CANBTC.bit.SAM = 0;

  ECanaRegs.CANBTC.bit.BRPREG = 19;    //500K 90M
  ECanaRegs.CANBTC.bit.TSEG2REG = 2;
  ECanaRegs.CANBTC.bit.TSEG1REG = 4;

  ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  ECanaShadow.CANMC.bit.CCR = 0;
  ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  EDIS;
  do
  {
ECanaShadow.CANES.all = ECanaRegs.CANES.all;
  }
  while(ECanaShadow.CANES.bit.CCE != 0);
}

void
ECan_Send_MB_Init(void)
{
  ECanaShadow.CANME.all = ECanaRegs.CANME.all;
  ECanaShadow.CANME.bit.ME1 = 0;
  ECanaRegs.CANME.all = ECanaShadow.CANME.all;

  ECanaShadow.CANMD.all = ECanaRegs.CANMD.all;
  ECanaShadow.CANMD.bit.MD1 = 0;
  ECanaRegs.CANMD.all = ECanaShadow.CANMD.all;

  ECanaMboxes.MBOX1.MSGID.bit.AME = 0;
  ECanaMboxes.MBOX1.MSGID.bit.AAM = 1;
  ECanaMboxes.MBOX1.MSGID.bit.IDE = 0;
  ECanaMboxes.MBOX1.MSGID.bit.STDMSGID = 0x191;
  ECanaMboxes.MBOX1.MSGID.bit.EXTMSGID_L = 0;
  ECanaMboxes.MBOX1.MSGID.bit.EXTMSGID_H = 0;

  ECanaMboxes.MBOX1.MSGCTRL.bit.RTR = 0;
  ECanaMboxes.MBOX1.MSGCTRL.bit.DLC = 8;

  EALLOW;
  ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  ECanaRegs.CANMC.bit.CDR = 1;
  ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  EDIS;

  ECanaMboxes.MBOX1.MDL.byte.BYTE1 = 1;
  ECanaMboxes.MBOX1.MDL.byte.BYTE2 = 2;
  ECanaMboxes.MBOX1.MDL.byte.BYTE3 = 3;
  ECanaMboxes.MBOX1.MDL.byte.BYTE4 = 4;
  ECanaMboxes.MBOX1.MDH.byte.BYTE5 = 5;
  ECanaMboxes.MBOX1.MDH.byte.BYTE6 = 6;
  ECanaMboxes.MBOX1.MDH.byte.BYTE7 = 7;
  ECanaMboxes.MBOX1.MDH.byte.BYTE8 = 8;

  EALLOW;
  ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
  ECanaRegs.CANMC.bit.CDR = 0;
  ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
  EDIS;

  ECanaShadow.CANME.all = ECanaRegs.CANME.all;
  ECanaShadow.CANME.bit.ME1 = 1;
  ECanaRegs.CANME.all = ECanaShadow.CANME.all;
}

只看该作者 · 2013-9-6 09:56

自己顶一下，，，

2万 · 2013-9-7 17:16

代码上没看出来哪儿不对了

1万 · 2013-9-8 07:19

楼主可能弄错了吧,
按照协议, 应答是在数据帧的最后面两位. 自动应答应该是指这个应答, 而不是应答一帧数据包

1万 · 2013-9-8 07:21

本帖最后由 airwill 于 2013-9-8 16:57 编辑

楼主可能弄错了吧?
按照协议. 应答是指数据帧里的最后那两位.
而并非自动回应一帧数据包.

只看该作者 · 2013-9-8 15:56

zhangmangui 发表于 2013-9-7 17:16
代码上没看出来哪儿不对了

版主：您好！之前的帖子没法结贴不知道怎么回事，实在抱歉。
请问，您同意airwill版主的说法吗？

只看该作者 · 2013-9-8 15:58

airwill 发表于 2013-9-8 07:21
楼主可能弄错了吧?
按照协议. 应答是指数据帧里的最后那两位.
而并非自动回应一帧数据包. ...

版主：
您好！
非常感谢您的热心回复。您提到的“数据帧里的最后那两位”是什么意思？请指教，谢谢！

只看该作者 · 2013-9-8 16:04

airwill 发表于 2013-9-8 07:21
楼主可能弄错了吧?
按照协议. 应答是指数据帧里的最后那两位.
而并非自动回应一帧数据包. ...

版主：
   下面是TI的一个例程，我是这样理解的：
   发送邮箱接收到与该邮箱ID相符的远程帧后，能够自动回复一个数据帧。
   不知道这样理解对不对，请指教，谢谢！

/*********************************************************************
* Filename: REMANS.c
*
Description: This test checks the ability of the CAN module to answer
remote frames automatically.
All mailboxes in 28x are configured as transmit mailboxes with the AAM
bit set. Each mailbox has a different ID. Mailboxes in node B (CANalyzer)
would transmit remote frames to all the 32 mailboxes in 28x, matching the
ID of mailboxes. The data frames will be received in mailboxes of node B.
This example verifies that RFPn bit is not set if AAM bit is not set.
* Last update: 12/26/2002
*********************************************************************/
#include ”DSP28_Device.h”
#define TXCOUNT 100000 // Transmission will take place (TXCOUNT) times..
long i;
long  loopcount = 0;
void infinite_loop();
void error(int);
void InitECan(void);
main()
{
/* Create a shadow register structure for the CAN control registers. This is
needed, since, only 32–bit access is allowed to these registers. 16–bit access
to these registers could potentially corrupt the register contents. This is
especially true while writing to a bit (or group of bits) among bits 16 –31 */
struct ECAN_REGS ECanaShadow;
/* Initialize the CAN module */
InitECan();
/* Write to the MSGID field ––> AAM bit = 1 */
ECanaMboxes.MBOX1.MSGID.all = 0x20040000; // Std identifier
ECanaMboxes.MBOX2.MSGID.all = 0x20080000; // Std identifier
ECanaMboxes.MBOX3.MSGID.all = 0x200C0000; // Std identifier
ECanaMboxes.MBOX4.MSGID.all = 0x20100000; // Std identifier
ECanaMboxes.MBOX5.MSGID.all = 0x20140000; // Std identifier
ECanaMboxes.MBOX6.MSGID.all = 0x20180000; // Std identifier
ECanaMboxes.MBOX7.MSGID.all = 0x201C0000; // Std identifier
ECanaMboxes.MBOX8.MSGID.all = 0x20200000; // Std identifier
ECanaMboxes.MBOX9.MSGID.all = 0x20240000; // Std identifier
ECanaMboxes.MBOX10.MSGID.all = 0x20400000; // Std identifier
ECanaMboxes.MBOX11.MSGID.all = 0x20440000; // Std identifier
ECanaMboxes.MBOX12.MSGID.all = 0x20480000; // Std identifier
ECanaMboxes.MBOX13.MSGID.all = 0x204C0000; // Std identifier
ECanaMboxes.MBOX14.MSGID.all = 0x20500000; // Std identifier
ECanaMboxes.MBOX15.MSGID.all = 0x20540000; // Std identifier
ECanaMboxes.MBOX16.MSGID.all = 0x20580000; // Std identifier
ECanaMboxes.MBOX17.MSGID.all = 0x205C0000; // Std identifier
ECanaMboxes.MBOX18.MSGID.all = 0x20600000; // Std identifier
ECanaMboxes.MBOX19.MSGID.all = 0x20640000; // Std identifier
ECanaMboxes.MBOX20.MSGID.all = 0x20800000; // Std identifier
ECanaMboxes.MBOX21.MSGID.all = 0x20840000; // Std identifier
ECanaMboxes.MBOX22.MSGID.all = 0x20880000; // Std identifier
ECanaMboxes.MBOX23.MSGID.all = 0x208C0000; // Std identifier
ECanaMboxes.MBOX24.MSGID.all = 0x20900000; // Std identifier
ECanaMboxes.MBOX25.MSGID.all = 0x20940000; // Std identifier
ECanaMboxes.MBOX26.MSGID.all = 0x20980000; // Std identifier
ECanaMboxes.MBOX27.MSGID.all = 0x209C0000; // Std identifier
ECanaMboxes.MBOX28.MSGID.all = 0x20A00000; // Std identifier
ECanaMboxes.MBOX29.MSGID.all = 0x20A40000; // Std identifier
ECanaMboxes.MBOX30.MSGID.all = 0x20C00000; // Std identifier
ECanaMboxes.MBOX31.MSGID.all = 0x20C40000; // Std identifier
ECanaMboxes.MBOX0.MSGID.all = 0x20C80000; // Std identifier
/* This block turns off AAM ––> AAM =0 */
/* ECanaMboxes.MBOX0.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX1.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX2.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX3.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX4.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX5.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX6.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX7.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX8.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX9.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX10.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX11.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX12.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX13.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX14.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX15.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX16.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX17.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX18.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX19.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX20.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX21.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX22.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX23.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX24.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX25.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX26.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX27.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX28.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX29.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX30.MSGID.bit.AAM = 0;
ECanaMboxes.MBOX31.MSGID.bit.AAM = 0; */
/* Configure Mailboxes 0–31 as Tx */
ECanaRegs.CANMD.all = 0x00000000;
/* Enable all Mailboxes */
ECanaRegs.CANME.all = 0xFFFFFFFF;
/* Write to Master Control field –DLC */
ECanaMboxes.MBOX0.MCF.bit.DLC = 8;
ECanaMboxes.MBOX1.MCF.bit.DLC = 8;
ECanaMboxes.MBOX2.MCF.bit.DLC = 8;
ECanaMboxes.MBOX3.MCF.bit.DLC = 8;
ECanaMboxes.MBOX4.MCF.bit.DLC = 8;
ECanaMboxes.MBOX5.MCF.bit.DLC = 8;
ECanaMboxes.MBOX6.MCF.bit.DLC = 8;
ECanaMboxes.MBOX7.MCF.bit.DLC = 8;
ECanaMboxes.MBOX8.MCF.bit.DLC = 8;
ECanaMboxes.MBOX9.MCF.bit.DLC = 8;
ECanaMboxes.MBOX10.MCF.bit.DLC = 8;
ECanaMboxes.MBOX11.MCF.bit.DLC = 8;
ECanaMboxes.MBOX12.MCF.bit.DLC = 8;
ECanaMboxes.MBOX13.MCF.bit.DLC = 8;
ECanaMboxes.MBOX14.MCF.bit.DLC = 8;
ECanaMboxes.MBOX15.MCF.bit.DLC = 8;
ECanaMboxes.MBOX16.MCF.bit.DLC = 8;
ECanaMboxes.MBOX17.MCF.bit.DLC = 8;
ECanaMboxes.MBOX18.MCF.bit.DLC = 8;
ECanaMboxes.MBOX19.MCF.bit.DLC = 8;
ECanaMboxes.MBOX20.MCF.bit.DLC = 8;
ECanaMboxes.MBOX21.MCF.bit.DLC = 8;
ECanaMboxes.MBOX22.MCF.bit.DLC = 8;
ECanaMboxes.MBOX23.MCF.bit.DLC = 8;
ECanaMboxes.MBOX24.MCF.bit.DLC = 8;
ECanaMboxes.MBOX25.MCF.bit.DLC = 8;
ECanaMboxes.MBOX26.MCF.bit.DLC = 8;
ECanaMboxes.MBOX27.MCF.bit.DLC = 8;
ECanaMboxes.MBOX28.MCF.bit.DLC = 8;
ECanaMboxes.MBOX29.MCF.bit.DLC = 8;
ECanaMboxes.MBOX30.MCF.bit.DLC = 8;
ECanaMboxes.MBOX31.MCF.bit.DLC = 8;
/* Write to the mailbox RAM field of MBOX0 –31 */
ECanaMboxes.MBOX0.MDRL.all = 0x9555AAA0;
ECanaMboxes.MBOX0.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX1.MDRL.all = 0x9555AAA1;
ECanaMboxes.MBOX1.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX2.MDRL.all = 0x9555AAA2;
ECanaMboxes.MBOX2.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX3.MDRL.all = 0x9555AAA3;
ECanaMboxes.MBOX3.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX4.MDRL.all = 0x9555AAA4;
ECanaMboxes.MBOX4.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX5.MDRL.all = 0x9555AAA5;
ECanaMboxes.MBOX5.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX6.MDRL.all = 0x9555AAA6;
ECanaMboxes.MBOX6.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX7.MDRL.all = 0x9555AAA7;
ECanaMboxes.MBOX7.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX8.MDRL.all = 0x9555AAA8;
ECanaMboxes.MBOX8.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX9.MDRL.all = 0x9555AAA9;
ECanaMboxes.MBOX9.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX10.MDRL.all = 0x9555AAAA;
ECanaMboxes.MBOX10.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX11.MDRL.all = 0x9555AAAB;
ECanaMboxes.MBOX11.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX12.MDRL.all = 0x9555AAAC;
ECanaMboxes.MBOX12.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX13.MDRL.all = 0x9555AAAD;
ECanaMboxes.MBOX13.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX14.MDRL.all = 0x9555AAAE;
ECanaMboxes.MBOX14.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX15.MDRL.all = 0x9555AAAF;
ECanaMboxes.MBOX15.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX16.MDRL.all = 0x9555AA10;
ECanaMboxes.MBOX16.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX17.MDRL.all = 0x9555AA11;
ECanaMboxes.MBOX17.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX18.MDRL.all = 0x9555AA12;
ECanaMboxes.MBOX18.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX19.MDRL.all = 0x9555AA13;
ECanaMboxes.MBOX19.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX20.MDRL.all = 0x9555AA14;
ECanaMboxes.MBOX20.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX21.MDRL.all = 0x9555AA15;
ECanaMboxes.MBOX21.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX22.MDRL.all = 0x9555AA16;
ECanaMboxes.MBOX22.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX23.MDRL.all = 0x9555AA17;
ECanaMboxes.MBOX23.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX24.MDRL.all = 0x9555AA18;
ECanaMboxes.MBOX24.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX25.MDRL.all = 0x9555AA19;
ECanaMboxes.MBOX25.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX26.MDRL.all = 0x9555AA1A;
ECanaMboxes.MBOX26.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX27.MDRL.all = 0x9555AA1B;
ECanaMboxes.MBOX27.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX28.MDRL.all = 0x9555AA1C;
ECanaMboxes.MBOX28.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX29.MDRL.all = 0x9555AA1D;
ECanaMboxes.MBOX29.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX30.MDRL.all = 0x9555AA1E;
ECanaMboxes.MBOX30.MDRH.all = 0x89ABCDEF;
ECanaMboxes.MBOX31.MDRL.all = 0x9555AA1F;
ECanaMboxes.MBOX31.MDRH.all = 0x89ABCDEF;
ECanaRegs.CANTA.all = 0xFFFFFFFF; // Clear any TA bits that might be set
/* Wait for remote frames.. */
while(1)  {}
}

/*
Observations:
Case 1: AAM = 1 in a Transmit mailbox:
––––––––––––––––––––––––––––––––––––––
The 28x correctly transmits the data frames upon reception of remote frames.
The RFP bits cannot be seen ”set”because they are cleared automatically by
the 28x. TAn bits are set after successful transmission.
Case 2: AAM = 0 in a Transmit mailbox:
––––––––––––––––––––––––––––––––––––––
The RFPn bit is not set. No data gets transmitted.
Case 3: AAM = 0 in a Receive mailbox:
––––––––––––––––––––––––––––––––––––––
The RFPn and RMPn bits will be set. These bits can be cleared by writing a
one to them. TAn bits will not be set and no data will be transmitted.
Case 4: AAM = 1 in a Receive mailbox:
––––––––––––––––––––––––––––––––––––––
The RFPn and RMPn bits will be set. These bits can be cleared by writing a
one to them. TAn bits will not be set and no data will be transmitted.
Use REMOTE.CFG in CANalyzer.
*/

2万 · 2013-9-8 21:36

孤独求粗发表于 2013-9-8 15:56
版主：您好！之前的帖子没法结贴不知道怎么回事，实在抱歉。
请问，您同意airwill版主的说法吗？ ...

哈哈同意同意 airwill大牛经验丰富
没法结贴说明你的悬赏分没有分配完吧如果还是不行就给我发消息

只看该作者 · 2013-9-9 11:13

关注，学习

只看该作者 · 2013-9-9 17:02

airwill 发表于 2013-9-8 07:21
楼主可能弄错了吧?
按照协议. 应答是指数据帧里的最后那两位.
而并非自动回应一帧数据包.

版主：CAN的通信机制我再好好研究一下，我从网上查的一点资料如下，难道是他说的有问题？
首先我们要搞清数据帧和远程帧的区别。在以前的讲座中我们讲过：
1 数据帧数据帧由7个不同的位场组成，即帧起始、仲裁场、控制场、数据场、CRC场、应答场、帧结束。
2 远程帧远程帧由6个不同的位场组成，即帧起始、仲裁场、控制场、CRC场、应答场、帧结束。可以看出它们的区别在于有没有数据场。群里的人提出TI的TMS320F2**和saj1000对于远程帧的处理不一样，是对的。其实这个设计到硬件本身的问题，TI的TMS320F的几款芯片内嵌了can模块，一般称为eCAN模块，而SAJ1000是飞利浦的can独立控制器，他们在对待远程贞的处理上是不同的。
eCAN处理远程帧时分为两种情况：向其他节点请求数据和自动应答远程帧。这两种情况必须将报文控制寄存器中RTR位置“1”。要向其他节点请求数据，必须将某邮箱配置成接收邮箱，写入标识符，使能该邮箱，将CANTRS相应的位置“1”，就向总线上发送了一个远程帧。eCAN会将对方的应答信息存在这个邮箱（这得保证没有相同ID的其他接收邮箱）。自动应答远程帧时，邮箱配置成发送邮箱，且邮箱标识符寄存器中的AAM位必须置“1”，写入需要发送的数据。当该邮箱接收到其他节点发送来的远程帧时，CANTRS中的相应位自动置位，将报文发送到总线上。
而SJA1000接收到1帧信息后，根据RTR位来判断是否是远程帧，如果是远程帧，则根据制定的通信协议对该远程帧作出相应的回答，不能自动应答远程帧。

1万 · 2013-9-9 17:30

要向其他节点请求数据，必须将某邮箱配置成接收邮箱，写入标识符，使能该邮箱，将CANTRS相应的位置“1”，就向总线上发送了一个远程帧。eCAN会将对方的应答信息存在这个邮箱（这得保证没有相同ID的其他接收邮箱）。自动应答远程帧时，邮箱配置成发送邮箱，且邮箱标识符寄存器中的AAM位必须置“1”，写入需要发送的数据。当该邮箱接收到其他节点发送来的远程帧时，CANTRS中的相应位自动置位，将报文发送到总线上。

看样子, 的确是能够发送数据包. 可以对远程帧回应数据包.

只看该作者 · 2013-9-13 19:56

airwill 发表于 2013-9-9 17:30
要向其他节点请求数据，必须将某邮箱配置成接收邮箱，写入标识符，使能该邮箱，将CANTRS相应的位置“1”， ...

今天调试成功，程序没问题，只是初始化的位置不对，实际上没初始化成功。
eCAN处理远程帧时分为两种情况：
1、向其他节点请求数据；
2、自动应答远程帧；
第二种情况，自动应答远程帧时，邮箱配置成发送邮箱，且邮箱标识符寄存器中的AAM位必须置“1”，写入需要发送的数据（注意，邮箱数据要定时更新，例如100ms刷新一次）当该邮箱接收到其他节点发送来的远程帧时，CANTRS中的相应位自动置位，将报文发送到总线上。

个人总结，还有一种远程帧的应答方式，再次与大家分享：
例如用MB1接收远程帧，用MB1回复。
MB1设置为无屏蔽的接收邮箱，当接收到一帧数据时，通过这一帧数据的RTR位判断是否是远程帧，如果是远程帧，用MB2回复；
如果不是远程帧（数据帧）再做其他处理（如解析该数据帧）。
这种方式已经验证，也没有问题。

本人菜鸟级任务，有描述不对的地方，请多多指教。

1万 · 2013-9-13 20:05

恭喜楼主, 通过自己啃资料, 研究, 搞定这个问题.
我之前也不知道又这个自动应答远程帧的功能, 这个功能不错, 很有用.

只看该作者 · 2014-4-7 08:56

楼主说的初始化位置不对是指什么？
我的程序应该也是初始化问题，跳出初始化函数之后，初始化工作就白做了，正如楼主说的“实际上没初始化成功”。。。求指教

只看该作者 · 2014-4-10 13:59

g210c 发表于 2014-4-7 08:56
楼主说的初始化位置不对是指什么？
我的程序应该也是初始化问题，跳出初始化函数之后，初始化工作就白做了 ...

能不能把你的程序发给我一下，我现在正在搞这个，有些东西没搞懂。

只看该作者 · 2014-6-7 22:23

楼主您好，请问您说的这种初始化方法适用于CAN卡吗？我想通过CAN卡发送远程帧到28335，调用邮箱内的数据返回上位机，发送邮箱的寄存器也是按照AAM=1配置的，但是实现不了？

只看该作者 · 2014-12-6 15:14

孤独求粗发表于 2013-9-13 19:56
今天调试成功，程序没问题，只是初始化的位置不对，实际上没初始化成功。
eCAN处理远程帧时分为两种 ...

楼主所说的初始化不对是什么意思，我感觉可能是初始化不对，但是运行到应答位的时候，发现寄存器里面的值也都对啊，就是TA不置位

只看该作者 · 2014-12-23 15:24

airwill 发表于 2013-9-9 17:30
要向其他节点请求数据，必须将某邮箱配置成接收邮箱，写入标识符，使能该邮箱，将CANTRS相应的位置“1”， ...

您好，我最近在做，can通信的【远程帧------自动应答数据】模式，邮箱等的初始化，基本上都是严格按照技术资料配置的，可是就是通信不成功，普通的通信是收发成功的，也不知道哪里出了问题，所以想请教您一下，期待您的回复，谢谢。

只看该作者 · 2015-1-20 09:57

学习了

2812 Can发送邮箱无法置为自动应答模式

相关下载

相关帖子

技术领袖奖章

十世金身

坚毅之洋流

荣誉元老奖章

涓涓之细流

经常做客

技术新星奖章

偶尔光临