Что может привести к тому, что данные будут напечатаны правильно, затем неправильно, а затем повторятся? CAN-шина/общая передача

Я пытаюсь отправить данные с MPU6050, подключенного к Arduino Uno, на другой Uno через шину CAN, однако я не думаю, что это проблема, специфичная для шины CAN.

Короче, я отправляю два пакета по 8 байт в следующих форматах

Packet 1 - (uint32_t/ int16_t/ int16_t)
Packet 2 - (int16_t/ int16_t/ int16_t/ int16_t)

все преобразовано в байты таким образом;

int16_t byte2Int(int16_t output, int pos, uint8_t data[2]){
      for (int i = 0; i < 2; i++)
    {
      output += ((int16_t)data[i + pos]) << (i * 8);
    }
    return output;
}

где все должно иметь смысл, кроме части «int pos», которая находится в том месте буфера, где я хочу начать помещать данные, поскольку пакеты 1 и 2 имеют разные структуры.

Моя проблема в том, что с помощью всего лишь одного пакета я могу нормально распечатать значения, а с добавлением второго пакета я получаю следующее на последовательном мониторе;

AccX    AccY    AccZ  GyX    GyY     GyZ

16832   -816    928 -440    16832   -816
16984   -940    992 -449    16984   -940
16896   -804    988 -462    16896   -804
209 55  0   0   209 55
16900   -852    1080    -471    16900   -852
16900   -852    1080    -471    16900   -852
16984   -760    948 -481    16984   -760
16880   -824    896 -459    16880   -824
230 102 0   0   230 102
16928   -860    996 -422    16928   -860
16928   -860    996 -422    16928   -860
17004   -856    864 -466    17004   -856
17004   -856    864 -466    17004   -856
214 105 0   0   214 105
16964   -828    944 -446    16964   -828
16964   -828    944 -446    16964   -828

Как вы можете видеть, я получаю некоторые связные сообщения, затем некоторые зашифрованные, которые не имеют смысла, затем снова связные, и цикл продолжается. Не уверен в актуальности, но когда я впервые запускаю последовательный монитор, этого не происходит, затем, после изменения времени, примерно через 5 секунд, все начинает идти не так.

Я считаю, что это связано с моим программированием и тем, что я не могу надежно запрограммировать код, чтобы дождаться завершения первого сообщения, а затем отправить следующее, и они будут прочитаны правильно. Ниже приведена моя неловкая попытка отправить отправителю сообщение ACK, чтобы сообщить, что сообщение получено, и перейти к следующему сообщению. Я не программист по натуре, и выкладываю этот дрянной код, который потратил несколько дней, пытаясь разобраться, в надежде, что кто-нибудь укажет мне правильное направление.

Заранее извиняюсь.

// Пример отправки CAN
//

#include <mcp_can.h>
#include <SPI.h>
#include <Wire.h>

const int MPU_addr = 0x68; // I2C-адрес MPU-6050
uint32_t TimeMicro;
int16_t AccX, AccY, AccZ, Tmp, GyX, GyY, GyZ; 
int8_t data1[8], data2[8], rxBuf[8];
int Switch = 7;
long unsigned int rxId;
unsigned char len = 0;

#define CAN0_INT 2                              // Установите INT на контакт 2
MCP_CAN CAN0(10);     // Устанавливаем CS на контакт 10

void setup()
{
  Serial.begin(115200);

  // Инициализируем MCP2515, работающий на частоте 16 МГц, со скоростью передачи данных 500 Кбит/с и отключенными масками и фильтрами.
  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK) Serial.println("MCP2515 Initialized Successfully!");
  else Serial.println("Error Initializing MCP2515...");

  CAN0.setMode(MCP_NORMAL);   // Переходим в обычный режим, чтобы разрешить передачу сообщений

  pinMode(Switch, OUTPUT);
  digitalWrite(Switch, HIGH);

  Wire.begin();
  Wire.beginTransmission(MPU_addr);
  Wire.write(0x6B);  // регистр PWR_MGMT_1
  Wire.write(0);     // устанавливаем на ноль (пробуждает MPU-6050)
  Wire.endTransmission(true);


}

void loop()
{

  TimeMicro = millis();

  Wire.beginTransmission(MPU_addr);
  Wire.write(0x3B);  // начиная с регистра 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  Wire.requestFrom(MPU_addr, 14, true); // запрашиваем всего 14 регистров
  AccX = Wire.read() << 8 | Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
  AccY = Wire.read() << 8 | Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
  AccZ = Wire.read() << 8 | Wire.read(); // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
  Tmp = Wire.read() << 8 | Wire.read();
  GyX = Wire.read() << 8 | Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (ГИРО_XOUT_L)
  GyY = Wire.read() << 8 | Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
  GyZ = Wire.read() << 8 | Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (ГИРО_ZOUT_L)

  double2Byte(TimeMicro, 0, data1);
  int2Byte(AccX, 4, data1);
  int2Byte(AccY, 6, data1);

  int2Byte(AccZ, 0, data2);
  int2Byte(GyX, 2, data2);
  int2Byte(GyY, 4, data2);
  int2Byte(GyZ, 6, data2);  

  // отправка данных: ID = 0x100, стандартный кадр CAN, длина данных = 8 байт, 'data' = массив байтов данных для отправки
  byte sndStat = CAN0.sendMsgBuf(0x100, 0, 8, data1);

  if(!digitalRead(CAN0_INT))                         // Если на выводе CAN0_INT низкий уровень, читаем буфер приема
  {
    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Чтение данных: len = длина данных, buf = байт(ы) данных

    while(rxBuf[0] != 0x0A)
    {
      continue;
    }

  }
  delay(10);
  byte sndStat2 = CAN0.sendMsgBuf(0x100, 0, 8, data2);

    while(rxBuf[0] != 0x0A)
    {
      continue;
    }

  for(int i = 0; i < 8; i++)
  {
    data1[i] = 0;
    data2[i] = 0;
  }

}

//============================================== ==================================
// ФУНКЦИИ
//============================================== ==================================
uint8_t int2Byte(int16_t input, int pos, uint8_t data[2]){
  for (int i = 0; i < 2; i++)
  {
    data[i+ pos] = ((input >> (i * 8)) & 0xff);
  }
return data[2];
}

uint8_t double2Byte(uint32_t input, int pos, uint8_t data[4]){
  for (int i = 0; i < 4; i++)
  {
    data[i+ pos] = ((input >> (i * 8)) & 0xff);
  }
return data[4];
}



/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

Получатель

// Пример приема CAN
//

#include <mcp_can.h>
#include <SPI.h>

long unsigned int rxId;
unsigned char len = 0;
unsigned char rxBuf1[8];
unsigned char rxBuf2[8];
unsigned char txBuf[8];
char msgString[128];                        // Массив для хранения последовательной строки
uint32_t TimeMicro;
int16_t AccX, AccY, AccZ, GyX, GyY, GyZ;

#define CAN0_INT 2                              // Установите INT на контакт 2
MCP_CAN CAN0(10);                               // Устанавливаем CS на контакт 10


void setup()
{
  Serial.begin(115200);

  // Инициализируем MCP2515, работающий на частоте 16 МГц, со скоростью передачи данных 500 Кбит/с и отключенными масками и фильтрами.
  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)
    Serial.println("MCP2515 Initialized Successfully!");
  else
    Serial.println("Error Initializing MCP2515...");

  CAN0.setMode(MCP_NORMAL);                     // Установите нормальный режим работы, чтобы MCP2515 отправлял подтверждения на полученные данные.

  pinMode(CAN0_INT, INPUT);                            // Настройка вывода для входа /INT

  Serial.println("MCP2515 Library Receive Example...");
}

void loop()
{
  if(!digitalRead(CAN0_INT))                         // Если на выводе CAN0_INT низкий уровень, читаем буфер приема
  {
    CAN0.readMsgBuf(&rxId, &len, rxBuf1);      // Чтение данных: len = длина данных, buf = байт(ы) данных
  }

  for(int i; i < 8; i++){
    txBuf[i] = 0x0A;
  }

  byte sndStat = CAN0.sendMsgBuf(0x101, 0, 8, txBuf);

  if(!digitalRead(CAN0_INT))                         // Если на выводе CAN0_INT низкий уровень, читаем буфер приема
  {
  CAN0.readMsgBuf(&rxId, &len, rxBuf1);      // Чтение данных: len = длина данных, buf = байт(ы) данных
  }

  byte sndStat2 = CAN0.sendMsgBuf(0x101, 0, 8, txBuf);


  TimeMicro = byte2Double(TimeMicro, 0, rxBuf1);
  AccX = byte2Int(AccX, 4, rxBuf1);
  AccY = byte2Int(AccY, 6, rxBuf1);
  AccZ = byte2Int(AccZ, 0, rxBuf2);
  GyX = byte2Int(GyX, 2, rxBuf2);
  GyY = byte2Int(GyY, 4, rxBuf2);
  GyZ = byte2Int(GyZ, 6, rxBuf2);


  Serial.print(TimeMicro);
  Serial.print("\t");
  Serial.print(AccX);
  Serial.print("\t");
  Serial.print(AccY);
  Serial.print("\t");
  Serial.print(AccZ);
  Serial.print("\t");
  Serial.print(GyX);
  Serial.print("\t");
  Serial.print(GyY);
  Serial.print("\t");
  Serial.println(GyZ);



  TimeMicro = 0;
  AccX = 0;
  AccY = 0;
  AccZ = 0;
  GyX = 0;
  GyY = 0;
  GyZ = 0;


}

//============================================== ==================================
// ФУНКЦИИ
//============================================== ==================================

uint32_t byte2Double(uint32_t output, int pos, uint8_t data[4]){
      for (int i = 0; i < 4; i++)
    {
      output += ((uint32_t)rxBuf1[i + pos]) << (i * 8);
    }
    return output;
}

int16_t byte2Int(int16_t output, int pos, uint8_t data[2]){
      for (int i = 0; i < 2; i++)
    {
      output += ((int16_t)rxBuf1[i + pos]) << (i * 8);
    }
    return output;
}
/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

Я пробовал отладить это следующим образом:

• проверьте, что MPU отправляет правильно (хорошо)
• проверьте, происходит ли это только с одним пакетом (без проблем)
• проверьте, правильно ли собраны пакеты на отправителе (получили данные, разбил его на байты, собрал и распечатал результат. сделал то, что я ожидается)
• убрано время из отправки, если это вызывало проблему (та же проблема как показано выше)
• удалены все серийные отпечатки и задано только одно значение (проблема все еще существует)

Поэтому я считаю, что это связано с ужасной и неэффективной попыткой отправить сообщение с подтверждением. Я пробовал исследовать, но не смог найти пример для CAN-шины, а все остальные использовали процедуры прерываний, специфичные для протокола, которые я пытался реализовать, но не сработало. очевидно.

Спасибо за терпение