Arduino SPI接口读取随机值？（尝试使用CAN总线屏蔽）_Arduino_Spi_Can Bus

Arduino SPI接口读取随机值？（尝试使用CAN总线屏蔽）

arduino

Arduino SPI接口读取随机值？（尝试使用CAN总线屏蔽）,arduino,spi,can-bus,Arduino,Spi,Can Bus,我在设置Arduino CAN总线通信时遇到了一个奇怪的问题描述如下，此视频显示结果：（备注：我试过的每一块板都会产生这种效果）硬件：不同的Arduino或Arduino等效板（目前为AZ交付UNO，也尝试使用Arduino Mega和Arduino UNO）来自SeedStudio的CAN总线屏蔽（V1.2）（请参阅）使用过的软件：我用我的2个Arduinos（不是Mega，它不兼容）和2个CAN总线屏蔽开始了完整的设置，我想，初始化失败了，然后突然成功了。我猜是关于焊接引

我在设置Arduino CAN总线通信时遇到了一个奇怪的问题

描述如下，此视频显示结果：

（备注：我试过的每一块板都会产生这种效果）

硬件：

不同的Arduino或Arduino等效板（目前为AZ交付UNO，也尝试使用Arduino Mega和Arduino UNO）
来自SeedStudio的CAN总线屏蔽（V1.2）（请参阅）

使用过的软件：

我用我的2个Arduinos（不是Mega，它不兼容）和2个CAN总线屏蔽开始了完整的设置，我想，初始化失败了，然后突然成功了。我猜是关于焊接引脚的，所以我重新进行了设置，但没有变得更好

经过大量测试，我得出了您在视频中看到的结果：我甚至不需要CAN总线屏蔽来初始化CAN总线屏蔽。如果我触摸SPI接口，它会将我识别为CAN总线屏蔽

通过CAN总线库，我检查了函数CAN.begin。它使用ISP引脚（2行中的6个引脚）来：

通过SPI将值写入地址
通过SPI从另一个地址读取两个值

通过SPI读取的代码（全部来自库，没有自己的代码！）

以及CAN.begin函数

int MCP2515Class::begin(long baudRate)
{
  CANControllerClass::begin(baudRate);

  pinMode(_csPin, OUTPUT);

  // start SPI
  SPI.begin();

  reset();

  writeRegister(REG_CANCTRL, 0x80);
  if (readRegister(REG_CANCTRL) != 0x80) {
    return 0;
  }

  const struct {
    long clockFrequency;
    long baudRate;
    uint8_t cnf[3];
  } CNF_MAPPER[] = {
    {  (long)8E6, (long)1000E3, { 0x00, 0x80, 0x00 } },
    {  (long)8E6,  (long)500E3, { 0x00, 0x90, 0x02 } },
    {  (long)8E6,  (long)250E3, { 0x00, 0xb1, 0x05 } },
    {  (long)8E6,  (long)200E3, { 0x00, 0xb4, 0x06 } },
    {  (long)8E6,  (long)125E3, { 0x01, 0xb1, 0x05 } },
    {  (long)8E6,  (long)100E3, { 0x01, 0xb4, 0x06 } },
    {  (long)8E6,   (long)80E3, { 0x01, 0xbf, 0x07 } },
    {  (long)8E6,   (long)50E3, { 0x03, 0xb4, 0x06 } },
    {  (long)8E6,   (long)40E3, { 0x03, 0xbf, 0x07 } },
    {  (long)8E6,   (long)20E3, { 0x07, 0xbf, 0x07 } },
    {  (long)8E6,   (long)10E3, { 0x0f, 0xbf, 0x07 } },
    {  (long)8E6,    (long)5E3, { 0x1f, 0xbf, 0x07 } },

    { (long)16E6, (long)1000E3, { 0x00, 0xd0, 0x82 } },
    { (long)16E6,  (long)500E3, { 0x00, 0xf0, 0x86 } },
    { (long)16E6,  (long)250E3, { 0x41, 0xf1, 0x85 } },
    { (long)16E6,  (long)200E3, { 0x01, 0xfa, 0x87 } },
    { (long)16E6,  (long)125E3, { 0x03, 0xf0, 0x86 } },
    { (long)16E6,  (long)100E3, { 0x03, 0xfa, 0x87 } },
    { (long)16E6,   (long)80E3, { 0x03, 0xff, 0x87 } },
    { (long)16E6,   (long)50E3, { 0x07, 0xfa, 0x87 } },
    { (long)16E6,   (long)40E3, { 0x07, 0xff, 0x87 } },
    { (long)16E6,   (long)20E3, { 0x0f, 0xff, 0x87 } },
    { (long)16E6,   (long)10E3, { 0x1f, 0xff, 0x87 } },
    { (long)16E6,    (long)5E3, { 0x3f, 0xff, 0x87 } },
  };

  const uint8_t* cnf = NULL;

  for (unsigned int i = 0; i < (sizeof(CNF_MAPPER) / sizeof(CNF_MAPPER[0])); i++) {
    if (CNF_MAPPER[i].clockFrequency == _clockFrequency && CNF_MAPPER[i].baudRate == baudRate) {
      cnf = CNF_MAPPER[i].cnf;
      break;
    }
  }

  if (cnf == NULL) {
    return 0;
  }

  writeRegister(REG_CNF1, cnf[0]);
  writeRegister(REG_CNF2, cnf[1]);
  writeRegister(REG_CNF3, cnf[2]);

  writeRegister(REG_CANINTE, FLAG_RXnIE(1) | FLAG_RXnIE(0));
  writeRegister(REG_BFPCTRL, 0x00);
  writeRegister(REG_TXRTSCTRL, 0x00);
  writeRegister(REG_RXBnCTRL(0), FLAG_RXM1 | FLAG_RXM0);
  writeRegister(REG_RXBnCTRL(1), FLAG_RXM1 | FLAG_RXM0);

  writeRegister(REG_CANCTRL, 0x00);
  if (readRegister(REG_CANCTRL) != 0x00) {
    return 0;
  }

  return 1;
}

int MCP2515Class:：begin（长波特率）
{
CANControllerClass:：begin（波特率）；
pinMode（_csPin，输出）；
//启动SPI
SPI.begin（）；
重置（）；
写注册表（注册表，0x80）；
如果（读寄存器（REG_CANCTRL）！=0x80）{
返回0；
}
常量结构{
长时钟频率；
长波特率；
uint8_t cnf[3]；
}CNF_制图员[]={
{（长）8E6，（长）1000E3，{0x00，0x80，0x00}，
{（长）8E6，（长）500E3，{0x00，0x90，0x02}，
{（长）8E6，（长）250E3，{0x00，0xb1，0x05}，
{（长）8E6，（长）200E3，{0x00，0xb4，0x06}，
{（长）8E6，（长）125E3，{0x01，0xb1，0x05}，
{（长）8E6，（长）100E3，{0x01，0xb4，0x06}，
{（长）8E6，（长）80E3，{0x01，0xbf，0x07}，
{（长）8E6，（长）50E3，{0x03，0xb4，0x06}，
{（长）8E6，（长）40E3，{0x03，0xbf，0x07}，
{（长）8E6，（长）20E3，{0x07，0xbf，0x07}，
{（长）8E6，（长）10E3，{0x0f，0xbf，0x07}，
{（长）8E6，（长）5E3，{0x1f，0xbf，0x07}，
{（长）16E6，（长）1000E3，{0x00，0xd0，0x82}，
{（长）16E6，（长）500E3，{0x00，0xf0，0x86}，
{（长）16E6，（长）250E3，{0x41，0xf1，0x85}，
{（长）16E6，（长）200E3，{0x01，0xfa，0x87}，
{（长）16E6，（长）125E3，{0x03，0xf0，0x86}，
{（长）16E6，（长）100E3，{0x03，0xfa，0x87}，
{（长）16E6，（长）80E3，{0x03，0xff，0x87}，
{（长）16E6，（长）50E3，{0x07，0xfa，0x87}，
{（长）16E6，（长）40E3，{0x07，0xff，0x87}，
{（长）16E6，（长）20E3，{0x0f，0xff，0x87}，
{（长）16E6，（长）10E3，{0x1f，0xff，0x87}，
{（长）16E6，（长）5E3，{0x3f，0xff，0x87}，
};
const uint8_t*cnf=NULL；
对于（无符号整数i=0；i<（sizeof（CNF_映射器）/sizeof（CNF_映射器[0]）；i++）{
if（CNF_映射器[i]。时钟频率==\u时钟频率和&CNF_映射器[i]。波特率==波特率）{
cnf=cnf_映射器[i].cnf；
打破
}
}
如果（cnf==NULL）{
返回0；
}
注册会计师（注册号CNF1，cnf[0]）；
注册会计师（注册号CNF2，cnf[1]）；
注册会计师（注册号CNF3，cnf[2]）；
登记员（登记处、旗帜（1）旗帜（0））；
写注册表（注册表项BFPCTRL，0x00）；
写入寄存器（寄存器TXRTSCTRL，0x00）；
写注册表（注册表项RXBnCTRL（0），标志为RXM1，标志为RXM0）；
写注册表（注册号RXBnCTRL（1），标志号RXM1 |标志号RXM0）；
写注册表（注册表，0x00）；
如果（读寄存器（REG_CANCTRL）！=0x00）{
返回0；
}
返回1；
}

2个问题：

这怎么可能，系统应该区分正确读数和简单错误，不是吗

我该怎么做才能让它运行

我怀疑shield演示程序不起作用，因为您没有将shield插入汽车总线

查看shield（）上Seeedstudio页面的Documents选项卡下的shield示意图，它看起来像是一个适配器，没有硬件可以对arduino说太多。我相信它需要插入汽车才能工作

正如您所演示的，can总线的软件检测并不是对插入汽车的屏蔽的可靠测试

在盾牌的“学习”选项卡下，有一个指向演示的链接。尽管演示视频不是英文的，但您可以看到，该电路板已插入汽车

祝您的项目好运！

相反，我相信“CAN总线屏蔽”是实际的控制器+收发器，因为Arduino AVR没有芯片上的控制器。你不需要汽车，但总线上需要另一个带电的CAN控制器。因此，同一总线上的这两个东西就可以了。谢谢你的回答。2个arduinos上有2个CAN总线屏蔽，其中一个发送wa，另一个接收wa这正是我的来源。两者都有一个随机的“CAN总线OK”-初始化行为，我收到随机的CAN总线消息。总线“应该”两个都配有120欧姆的电阻器。至少让一方工作来测试另一方确实会更容易。不过，在接下来的几天里获得硬件，控制器即使不可用也会被认可，这仍然很奇怪。我可能不受欢迎的意见是将您的Arduino+这些适配器板捐赠给electronics回收。由于过时的技术，这一切都变得如此复杂。取而代之的是一个带有CAN控制器的现代Cortex M芯片。这样你就不必担心SPI、臃肿软件库和多块板。

int MCP2515Class::begin(long baudRate)
{
  CANControllerClass::begin(baudRate);

  pinMode(_csPin, OUTPUT);

  // start SPI
  SPI.begin();

  reset();

  writeRegister(REG_CANCTRL, 0x80);
  if (readRegister(REG_CANCTRL) != 0x80) {
    return 0;
  }

  const struct {
    long clockFrequency;
    long baudRate;
    uint8_t cnf[3];
  } CNF_MAPPER[] = {
    {  (long)8E6, (long)1000E3, { 0x00, 0x80, 0x00 } },
    {  (long)8E6,  (long)500E3, { 0x00, 0x90, 0x02 } },
    {  (long)8E6,  (long)250E3, { 0x00, 0xb1, 0x05 } },
    {  (long)8E6,  (long)200E3, { 0x00, 0xb4, 0x06 } },
    {  (long)8E6,  (long)125E3, { 0x01, 0xb1, 0x05 } },
    {  (long)8E6,  (long)100E3, { 0x01, 0xb4, 0x06 } },
    {  (long)8E6,   (long)80E3, { 0x01, 0xbf, 0x07 } },
    {  (long)8E6,   (long)50E3, { 0x03, 0xb4, 0x06 } },
    {  (long)8E6,   (long)40E3, { 0x03, 0xbf, 0x07 } },
    {  (long)8E6,   (long)20E3, { 0x07, 0xbf, 0x07 } },
    {  (long)8E6,   (long)10E3, { 0x0f, 0xbf, 0x07 } },
    {  (long)8E6,    (long)5E3, { 0x1f, 0xbf, 0x07 } },

    { (long)16E6, (long)1000E3, { 0x00, 0xd0, 0x82 } },
    { (long)16E6,  (long)500E3, { 0x00, 0xf0, 0x86 } },
    { (long)16E6,  (long)250E3, { 0x41, 0xf1, 0x85 } },
    { (long)16E6,  (long)200E3, { 0x01, 0xfa, 0x87 } },
    { (long)16E6,  (long)125E3, { 0x03, 0xf0, 0x86 } },
    { (long)16E6,  (long)100E3, { 0x03, 0xfa, 0x87 } },
    { (long)16E6,   (long)80E3, { 0x03, 0xff, 0x87 } },
    { (long)16E6,   (long)50E3, { 0x07, 0xfa, 0x87 } },
    { (long)16E6,   (long)40E3, { 0x07, 0xff, 0x87 } },
    { (long)16E6,   (long)20E3, { 0x0f, 0xff, 0x87 } },
    { (long)16E6,   (long)10E3, { 0x1f, 0xff, 0x87 } },
    { (long)16E6,    (long)5E3, { 0x3f, 0xff, 0x87 } },
  };

  const uint8_t* cnf = NULL;

  for (unsigned int i = 0; i < (sizeof(CNF_MAPPER) / sizeof(CNF_MAPPER[0])); i++) {
    if (CNF_MAPPER[i].clockFrequency == _clockFrequency && CNF_MAPPER[i].baudRate == baudRate) {
      cnf = CNF_MAPPER[i].cnf;
      break;
    }
  }

  if (cnf == NULL) {
    return 0;
  }

  writeRegister(REG_CNF1, cnf[0]);
  writeRegister(REG_CNF2, cnf[1]);
  writeRegister(REG_CNF3, cnf[2]);

  writeRegister(REG_CANINTE, FLAG_RXnIE(1) | FLAG_RXnIE(0));
  writeRegister(REG_BFPCTRL, 0x00);
  writeRegister(REG_TXRTSCTRL, 0x00);
  writeRegister(REG_RXBnCTRL(0), FLAG_RXM1 | FLAG_RXM0);
  writeRegister(REG_RXBnCTRL(1), FLAG_RXM1 | FLAG_RXM0);

  writeRegister(REG_CANCTRL, 0x00);
  if (readRegister(REG_CANCTRL) != 0x00) {
    return 0;
  }

  return 1;
}