Use stm32 crc to compare DS18B20 crc

[Flour Beur]

Posted on February 25, 2018 at 11:10

Hello friend,

I have DS18B20. And I read his uniq ID with CRC.

And I know, that STM has crc calculator. 

So I read data from DS18B20:

• 0xab 0x1 0x4b 0x46 0x7f 0xff 0x5 0x10 :

  CRC 0x92

And I use internal calculator on this datas.

But result is wrong, because I get:

0x19

And you can see 0x92 is different from 0x19.

For example:

read ID with CRC.

uint8_t *p = ds18b20_read_serial_number();

And CRC calculation:

uint8_t test_crc = CRC_Calculate8(p, 8, 1);

Any idea, what is wrong?

Here is function to calc CRC in STM32F767zi.

uint32_t CRC_Calculate8(uint8_t* arr, uint32_t count, uint8_t reset)

{

/* Reset CRC data register if necessary */

if (reset) {

/* Reset generator */

LL_CRC_ResetCRCCalculationUnit(CRC); //CRC->CR = CRC_CR_RESET;

}

/* Calculate CRC */

while (count--) {

/* Set new value */

LL_CRC_FeedData8(CRC, *arr++); //CRC->DR = *arr++;

}

/* Return data */

return LL_CRC_ReadData8(CRC); //CRC->DR;

}

#crc

[Tesla DeLorean]

Posted on February 25, 2018 at 11:51

They use a different polynomial, width or shift direction?

[Flour Beur]

Posted on February 25, 2018 at 11:53

Ok. And can I recalculate to good value (for example some mask)?

Or I must sw calculating?

[Tesla DeLorean]

Posted on February 25, 2018 at 15:34

The hardware might be able to do it, but you likely spend as much time setting things up as doing the computation.

Here is an efficient 4-bit table implementation in software

// Dallas 1-Wire CRC Test App -

mailto:[e-mail]

//  x^8 + x^5 + x^4 + 1 0x8C (0x131)

//  Right Shift

//  Initialized to Zero

uint8_t Crc8CQuick(uint8_t Crc, int Size, uint8_t *Buffer)

{

  static const uint8_t CrcTable[] = { // Nibble table for polynomial 0x8C

    0x00,0x9D,0x23,0xBE,0x46,0xDB,0x65,0xF8, //

mailto:[e-mail]

    0x8C,0x11,0xAF,0x32,0xCA,0x57,0xE9,0x74 };

  while(Size--)

  {

    Crc ^= *Buffer++; // Apply Data

    Crc = (Crc >> 4) ^ CrcTable[Crc & 0x0F]; // Two rounds of 4-bits

    Crc = (Crc >> 4) ^ CrcTable[Crc & 0x0F];

  }

  return(Crc);

}

uint8_t Crc8CSlow(uint8_t Crc, int Size, uint8_t *Buffer)

{

  int i;

  while(Size--)

  {

    Crc ^= *Buffer++; // Apply Data

    for (i=0; i<8; i++) // 1-bit at a time

      if (Crc & 0x01)

        Crc = (Crc >> 1) ^ 0x8C; // Polynomial used in Dallas 1-Wire

      else

        Crc = (Crc >> 1);

  }

  return(Crc);

}

void test(void)

{

  uint8_t data[] = { // Supplied Test Data Vector

    0xab,0x01,0x4b,0x46,0x7f,0xff,0x05,0x10 }; // 0x92

  printf('%02X test\n', Crc8CQuick(0x00, sizeof(data), data));

  printf('%02X test\n', Crc8CSlow(0x00, sizeof(data), data));

}

Sorry about the formatting, will post a formatted version below but it will sit in moderation for a while.

Edit: Pastes better in FireFox than Chrome, will try a LL implementation later

[Flour Beur]

Posted on February 25, 2018 at 15:41

I thought so. So I calculate CRC with the same result with this function:

♯ define CRC8INIT 0x00

♯ define CRC8POLY 0x18 //0X18 = X^8+X^5+X^4+X^0

uint8_t ds18b20_crc8( uint8_t *data, uint16_t number_of_bytes_in_data )

{

   uint8_t crc;

   uint16_t loop_count;

   uint8_t bit_counter;

   uint8_t b;

   uint8_t feedback_bit;

   crc = CRC8INIT;

   for (loop_count = 0; loop_count != number_of_bytes_in_data; loop_count++)

   {

      b = data[loop_count];

      bit_counter = 8;

      do {

            feedback_bit = (crc ^ b) & 0x01;

            if ( feedback_bit == 0x01 )

            {

                  crc = crc ^ CRC8POLY;

            }

            crc = (crc >> 1) & 0x7F;

            if ( feedback_bit == 0x01 )

            {

               crc = crc | 0x80;

            }

            b = b >> 1;

            bit_counter--;

      } while (bit_counter > 0);

   }

   return crc;

}

[Tesla DeLorean]

Posted on February 25, 2018 at 17:04

// Dallas 1-wire CRC using STM32 hardware on models supporting user defined settings

// Bit more hacky than I'd like, rough framework lifted from

//  STM32Cube_FW_F7_V1.8.0\Projects\STM32F767ZI-Nucleo\Examples_LL\CRC\CRC_UserDefinedPolynomial

// CliveOne -

mailto:[e-mail]

#include 'stm32f7xx_ll_bus.h'

#include 'stm32f7xx_ll_crc.h'

#define  CRC8_POLYNOMIAL_VALUE 0x31 // 0x8C poly reversed (STM32 left shifts)

/* Test vector */

static const uint8_t aDataBuffer[] = {

  0xab,0x01,0x4b,0x46,0x7f,0xff,0x05,0x10 }; // 0x92

/* Expected CRC Value */

uint8_t ubExpectedCRCValue = 0x92;

/* Used for storing CRC Value */

uint8_t ubCRCValue = 0;

/**

  * @brief  This function configures CRC Instance.

  * @note   This function is used to :

  *         -1- Enable peripheral clock for CRC.

  *         -2- Configure CRC functional parameters.

  * @note   Peripheral configuration is minimal configuration from reset values.

  *         Thus, some useless LL unitary functions calls below are provided as

  *         commented examples - setting is default configuration from reset.

  * @param  None

  * @retval None

  */

void Configure_CRC(void)

{

  /* (1) Enable peripheral clock for CRC                   *********************/

  LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_CRC);

  /* (2) Configure CRC functional parameters  ********************************/

  /* Configure CRC calculation unit with user defined polynomial value, 8-bit long */

  LL_CRC_SetPolynomialCoef(CRC, CRC8_POLYNOMIAL_VALUE);

  LL_CRC_SetPolynomialSize(CRC, LL_CRC_POLYLENGTH_8B);

  LL_CRC_SetInitialData(CRC, 0); // ZERO

  LL_CRC_SetInputDataReverseMode(CRC, LL_CRC_INDATA_REVERSE_WORD); // STM32 backward

  LL_CRC_SetOutputDataReverseMode(CRC, LL_CRC_OUTDATA_REVERSE_BIT); // reverse bit order on read

}

/**

  * @brief  This function performs CRC calculation on BufferSize bytes from input data buffer aDataBuffer.

  * @param  BufferSize Nb of bytes to be processed for CRC calculation

  * @retval 8-bit CRC value computed on input data buffer

  */

uint8_t Calculate_CRC(uint32_t BufferSize, uint8_t *Buffer)

{

  register uint32_t data = 0;

  register uint32_t index = 0;

  /* Compute the CRC of Data Buffer array*/

  for(index=0; index < (BufferSize / 4); index++)

  {

    data = (uint32_t)((Buffer[4 * index + 3] << 24) | (Buffer[4 * index + 2] << 16) | (Buffer[4 * index + 1] << 8) | Buffer[4 * index]);

    LL_CRC_FeedData32(CRC, data);

  }

  /* Last bytes specific handling */

  if ((BufferSize % 4) != 0)

  {

    if (BufferSize % 4 == 1)

    {

      LL_CRC_FeedData8(CRC, Buffer[4 * index]);

    }

    if (BufferSize % 4 == 2)

    {

      LL_CRC_FeedData16(CRC, (uint16_t)((Buffer[4 * index + 1]<<8) | Buffer[4 * index]));

    }

    if (BufferSize % 4 == 3)

    {

      LL_CRC_FeedData16(CRC, (uint16_t)((Buffer[4 * index + 1]<<8) | Buffer[4 * index]));

      LL_CRC_FeedData8(CRC, Buffer[4 * index + 2]);

    }

  }

  /* Return computed CRC value */

  return(LL_CRC_ReadData8(CRC));

}

/**

  * @brief  Check CRC computation result value.

  * @param  None

  * @retval None

  */

void CheckCRCResultValue(void)

{

  printf('CRC:%02X (%02X)\n', ubCRCValue, ubExpectedCRCValue);

  /* Compare the CRC value to the Expected one */

  if (ubCRCValue != ubExpectedCRCValue)

    puts('CRC **FAILED**');

  else

    puts('CRC Passed');

}

void Test(void)

{

  /* Configure CRC (CRC IP configuration using user-defined Polynomial value) */

  Configure_CRC();

  /* Perform CRC calculation on data contained in aDataBuffer */

  ubCRCValue = Calculate_CRC(sizeof(aDataBuffer), aDataBuffer);

  /* Check if CRC computed result value is equal to expected one */

  CheckCRCResultValue();

}

[Flour Beur]

Posted on February 25, 2018 at 17:23

It is look like fantastic.

I'm trying it tomorrow. Thank you. 

i forgot to examples in CubeMX.

[Tesla DeLorean]

Posted on February 25, 2018 at 17:36

The HAL/Cube examples for the LL are pretty sparse. The above could be coded more efficiently.

I built the test framework on an STM32F746G-DISCO