Projektbeispiel Vermessungsgerät Teil 5

  uint8_t buffer[8];
  ret = spi_read_packet(buffer, 64);
  if (ret != RET_OK)
    return ret;

  // Wir müssen die Byte Order umkehren, da der SoC Little Endian ist, Acuro Big Endian. Das ganze machen wir LINKSBÜNDIG in einen UInt64
  uint64_t bit_vector = 0;
  uint8_t* packet = (uint8_t*)&bit_vector;
  for (int pos = 0; pos < 8; pos++)
    packet[7-pos] = buffer[pos];

  // so, nun müssen wir die "Startsequenz" des Acuro-Pakets wegschneiden. Zunächst zwei führende 1 nach Spezifikation
  bool isValid = false;
  size_t position = 0;
  for (int pos = 0; pos < 4; pos++)
  {
    if (!(bit_vector & highest_bit))
    {
      isValid = true;
      break;
    }

    bit_vector <<= 1;
    position++;
  }
  
  if (!isValid)
    return ERR_ACURO_PROT_1;

  // nun muss der Sensor mit low quitiert haben. Variabel ist aber seine busy Zeit, in der er low bleibt. Wir schneiden nun führende 0 weg, auch deren Anzahl ist durch max busy time begrenzt, was wir natürlich testen.
  isValid = false;
  for (int pos = 0; pos < 6; pos++)
  {
    if (bit_vector & highest_bit)
    {
      isValid = true;
      break;
    }

    bit_vector <<= 1;
    position++;
  }
  
  if (!isValid)
    return ERR_ACURO_PROT_2;

  // Jetzt kommt noch das Startbit des Acuro-Pakets weg.
  bit_vector <<= 1;
  position++;

  // Jipi, der Rest ist nun unser Acuro Paket, linksbündig ausgerichtet. ACHTUNG: der Winkelwert ist natürlich ... Little Endian!
  // Wo wir das Paket so schön linksbündig haben, ist es ideal ausgerichtet für unseren CRC check. Daher machen wir uns mal hier eine Kopie für später.
  uint64_t value_for_crc = bit_vector;

  // Nun wollen wir den Inhalt "per Maske" auslesen. Daher machen wir das Paket jetzt rechtsbündig.	
  bit_vector >>= RIGHT_SHIFT;
  
   // Als Maske nehmen wir der Einfach halber einen struct. Kann man auch zu Fuß machen, muss man aber nicht.	
  const acuro_packet* a_packet = (const acuro_packet*)&bit_vector;
   
  // So, nun machen wir auch unseren CRC Test
  uint8_t crc = compute_crc(value_for_crc);

#include <stdio.h>

/**
  Ein Generatorpolynom als Bitmaske direkt für die Verarbeitung im 64 Bit Register.
  
  \author    Dr. Torsten Thurow
*/
typedef struct
{
  uint64_t mask;                                ///< Die Bitmaske selbst, das MSB mit Wert 1 ist dabei linksbündig ausgerichtet (Bit 63 bei Zählweise startend mit 0)
  size_t length;                                ///< Die Anzahl der Bits des Polynoms, entspricht dem Grad des Polynoms + 1
} PolynomMask;

const static uint64_t testMask = ((uint64_t)1 << 63); ///< testMask dient der einfachen Prüfung, ob ein 64 Bit Wert linksbündig eine 1 besitzt (Bit 63 bei Zählweise startend mit 0)

/**
  Erstellt aus einem Generatorpolynom eine linksseitig orientierte Bitmaske.
  
  \author    Dr. Torsten Thurow
  
  \param    polynom        Das Generatorpolynom als Wert.
  
  \returns  Eine linksseitig orientierte Bitmaske generiert aus dem Generatorpolynom.
*/
constexpr PolynomMask CreatePolynomMask(uint64_t polynom)
{
  PolynomMask polynomMask = { polynom, 64 };    // zunächst wird die Maske mit dem Polynomwert und dem Längenwert, der noch bestimmt wird, mit maximal 64 Bit, initialisiert
  while (!(polynomMask.mask & testMask))        // solange das höchste Bit 63 (bei Zählweise startend mit 0) 0 ist
  {
    polynomMask.mask <<= 1;                     // schiebe die Bitsequenz eine Stelle weiter nach link
    polynomMask.length--;                       // das bedeutet aber auch, der Längenwert muss wieder ein Bit geringer sein, denn das Polynom startet prinzipbedingt immer mit 1
  }
  return polynomMask;                           // die Maske ist fertig
}

#ifdef CRC_OUTPUT
/**
  Gibt die einzelnen Bits einer Bitsequenz menschenlesbar aus.
  
  \author    Dr. Torsten Thurow
  
  \param    value         Die Bitsequenz als 64 Bit Integer.
  \param    offset        Nummer des ersten Bits, welches ausgegeben wird, in der Orientierung vom höchstwertigen Bit zum niederwertigsten Bit.
  \param    length        Anzahl der Bits, welche ausgegeben werden.
*/
void PrintBits(uint64_t value, size_t offset, size_t length)
{
  if (!length)
    return;

  value <<= offset;
  while (true)
  {
    std::cout << (value & testMask ? '1' : '0');
    value <<= 1;
    length--;
    if (!length)
      break;
    std::cout << ' ';
  }
  std::cout << std::endl << std::flush;
}
#endif // CRC_OUTPUT

/**
  Der eigentliche CRC-Algorithmus für die Berechnung des CRC Wertes wie auch dessen Kontrolle
  
  \author    Dr. Torsten Thurow
  
  \param    value          Die Bitsequenz als 64 Bit Integer.
  \param    length         Die Länge der Bitsequenz als Anzahl Bits.
  \param    polynomMask    Das Generatorpolynom als Bitmaske.
  
  \returns  An uint64_t.
*/
static uint64_t Calculate(uint64_t value, size_t length, PolynomMask polynomMask)
{
  // Zuerst wird der Rahmen links ausgerichtet
  value <<= 64 - length;
  while (true)
  {
#ifdef CRC_OUTPUT
    // Die Bitsequenz wird ausgegeben
    PrintBits(value, 0, length + polynomMask.length - 1);
#endif //  CRC_OUTPUT
    
    // Nun werden alle führenden Nullen entfernt
    while (!(value & testMask)) // solange das höchste Bit 63 (bei Zählweise startend mit 0) 0 ist
    {
      value <<= 1;                              // schiebe die Bitsequenz eine Stelle weiter nach link
      length--;                                 // von der Ursprungssequenz wird nach dem Shift nach Links ein Bit weniger vorgehalten
      if (!length)                              // wenn die gesamte Ursprungssequenz abgearbeitet wurde ...
        return value;                           // ... verbleibt nur noch der CRC Wert linksbündig
    }

#ifdef CRC_OUTPUT
    PrintBits(polynomMask.mask, 0, polynomMask.length);
#endif //  CRC_OUTPUT
    
    value ^= polynomMask.mask;                  // hier erfolgt die XOR-Operation zwischen (Rest)Wert und Generatorpolynom
  }
}