Calculate CRC-8-ATM with Hardware CRC Unit of STM32F7

[Flo25]

How can you calculate a CRC-8-ATM using the CRC unit of a STM32F7?

I want to check the CRC of the output of an ADC ADS127L11 which is transmitted via SPI. The user manual says the CRC calculation is based on CRC-8-ATM. The output is an 8-bit CRC, and the polynomial is X^8+X^2+X^1+X^0. I cannot configure this in the CRC unit of my STM32F7.

Does anybody know if and how you can use the embedded CRC unit for CRC-8-ATM calculation?

[Tesla DeLorean]

So an 0x07 polynomial value.

You want to use the CRC unit built into the SPI, or the stand-alone CRC unit of the STM32?

Do you have some example test vectors?

Have you checked it with a software implementation?

Generally on the SPI, I'd expect you run the pattern through the reception, with the CRC polynomial set up, and if correct the CRC register/check will zero out.

[Flo25]

Thanks for your answer. Basically, I was an ***.

Here is an excerpt of my solution. Yes, I see there some weaknesses in returning how to return the values, it’s an excerpt. Maybe it helps someone.

#include "stm32f756xx.h"

#define CONFIG_COUNT 1u

typedef enum
{
  REV_IN_NOT_AFFECTED = 0uL,             //!< 00: Bit order not affected
  REV_IN_BYTE =         CRC_CR_REV_IN_0, //!< 01: Bit reversal done by byte
  REV_IN_HALF_WORD =    CRC_CR_REV_IN_1, //!< 10: Bit reversal done by half-word
  REV_IN_WORD =         CRC_CR_REV_IN    //!< 11: Bit reversal done by word
} InBitInversionMode_t;

typedef enum {
  POLY_SIZE_32 = 0x0uL,             //!< 32 Bit polynomial
  POLY_SIZE_16 = CRC_CR_POLYSIZE_0, //!< 16 Bit polynomial
  POLY_SIZE_8  = CRC_CR_POLYSIZE_1, //!<  8 Bit polynomial
  POLY_SIZE_7  = CRC_CR_POLYSIZE    //!<  7 Bit polynomial
} PolySize_t;

typedef struct
{
  bool isOutBitInverted;              //!< Reversal of the bit order of the output data
  InBitInversionMode_t inBitInverted; //!< Reversal of the bit order of the input data
  PolySize_t polySize;                //!< Size of the CRC polynomial
  uint32_t crcPoly;                   //!< Programmable CRC polynomial
  uint32_t crcInit;                   //!< Initial CRC value
} CrcConfig_t;

static const CrcConfig_t crcConfig[CONFIG_COUNT] =
{
  { // HAL_CRC_ADC
    false,
    REV_IN_NOT_AFFECTED,
    POLY_SIZE_8,
    0x07uL,              //!< CRC_8_ATM -> X^8 + X^2 + X^1 + X^0
    0xFFFFFFFFuL
  }
}

void HalCrc_Init(void)
{
  RCC->AHB1ENR |= RCC_AHB1ENR_CRCEN; // Enable CRC clock
  CRC->CR = CRC_CR_RESET;
}

void HalCrc_Config(const HalCrc_Config_t config)
{
  CRC->CR = CRC_CR_RESET;
  
  CRC->POL = (uint32_t)(crcConfig[config].crcPoly);
  CRC->INIT = (uint32_t)(crcConfig[config].crcInit);
  
  CRC->CR |= (crcConfig[config].isOutBitInverted) ? CRC_CR_REV_OUT: 0uL;
  CRC->CR |= (uint32_t)(crcConfig[config].inBitInverted);
  CRC->CR |= (uint32_t)(crcConfig[config].polySize);
}

void HalCrc_Calculate8(uint32_t* const crc, const uint8_t* data, const uint8_t length)
{
  CRC->CR |= CRC_CR_RESET;
  for(uint8_t bytePos = 0; bytePos < length; bytePos++)
  {
    *(uint8_t*)(CRC_BASE) = data[bytePos]; // Write data to CRC data register
  }
  *crc = CRC->DR;
}

uint32_t HalCrc_Accumulate8(const uint8_t data)
{
  *(uint8_t*)(CRC_BASE) = data; // Write data to CRC data register
  return CRC->DR;
}