STM32L4R5板子CRC程序的问题

chenbingjy

STM32L4R5板子CRC程序的问题 [复制链接]

 

代码：

#include "main.h"

/** @addtogroup STM32L4xx_HAL_Examples
  * @{
  */

/** @addtogroup CRC_UserDefinedPolynomial
  * @{
  */

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* aDataBuffer is 32 bit long*/
#define BUFFER_SIZE 1

/* The user defined polynomial*/
#define CRC_POLYNOMIAL_8B 0x9B /* X^8 + X^7 + X^4 + X^3 + X + 1 */

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* CRC handler declaration */
CRC_HandleTypeDef   CrcHandle;

/* Used for storing CRC Value */
__IO uint32_t uwCRCValue = 0;

/* Buffer containing the data on which the CRC will be calculated 
  (one-word buffer in this example) */
static const uint32_t aDataBuffer = 0x1234;

/* Expected CRC Value */
uint32_t uwExpectedCRCValue = 0xEF;

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void Error_Handler(void);

/* Private functions ---------------------------------------------------------*/

/**
  * [url=home.php?mod=space&uid=159083]@brief[/url] Main program
  * @param  None
  * @retval None
  */
int main(void)
{
  
  /* STM32L4xx HAL library initialization:
       - Configure the Flash prefetch
       - Systick timer is configured by default as source of time base, but user 
         can eventually implement his proper time base source (a general purpose 
         timer for example or other time source), keeping in mind that Time base 
         duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and 
         handled in milliseconds basis.
       - Set NVIC Group Priority to 4
       - Low Level Initialization
     */
  HAL_Init();
  
  /* Configure the system clock to 120 MHz */
  SystemClock_Config();

  /* Configure LED1 and LED3 */
  BSP_LED_Init(LED1);
  BSP_LED_Init(LED3);

  /*##-1- Configure the CRC peripheral #######################################*/
  CrcHandle.Instance = CRC;

  /* The default polynomial is not used. It is required to defined it in CrcHandle.Init.GeneratingPolynomial*/  
  CrcHandle.Init.DefaultPolynomialUse    = DEFAULT_POLYNOMIAL_DISABLE;
  
  /* Set the value of the polynomial */
  CrcHandle.Init.GeneratingPolynomial    = CRC_POLYNOMIAL_8B;
  
  /* The user-defined generating polynomial generates a
     8-bit long CRC */
  CrcHandle.Init.CRCLength               = CRC_POLYLENGTH_8B;

  /* The default init value is used */
  CrcHandle.Init.DefaultInitValueUse     = DEFAULT_INIT_VALUE_ENABLE;

  /* The input data are not inverted */
  CrcHandle.Init.InputDataInversionMode  = CRC_INPUTDATA_INVERSION_NONE;

  /* The output data are not inverted */
  CrcHandle.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_DISABLE;

  /* The input data are 32-bit long */
  CrcHandle.InputDataFormat              = CRC_INPUTDATA_FORMAT_WORDS;

  if (HAL_CRC_Init(&CrcHandle) != HAL_OK)
  {
    /* Initialization Error */
    Error_Handler();
  }

  /*##-2- Compute the CRC of "aDataBuffer" ###################################*/
  uwCRCValue = HAL_CRC_Calculate(&CrcHandle, (uint32_t *)&aDataBuffer, BUFFER_SIZE);

  /*##-3- Compare the CRC value to the Expected one ##########################*/
  if (uwCRCValue != uwExpectedCRCValue)
  {
    /* Wrong CRC value: Turn LED3 on */
    Error_Handler();
  }
  else
  {
    /* Right CRC value: Turn LED1 on */
    BSP_LED_On(LED1);
  }

  /* Infinite loop */
  while (1)
  {
  }
}

我想知道怎么算出来的。于是我写了一个C程序验证

#include "stdio.h"

#define uint32_t unsigned  int
#define uint16_t unsigned short
#define uint8_t  unsigned char

#define BUFFER_SIZE    1

uint32_t  temp;

static const uint32_t aDataBuffer = 0x1234;

/******************************************************************************
 * Name:    CRC-32/MPEG-2  x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
 * Poly:    0x4C11DB7
 * Init:    0xFFFFFFF
 * Refin:   False
 * Refout:  False
 * Xorout:  0x0000000
 *****************************************************************************/
uint32_t crc32_mpeg_2(uint32_t *data, uint16_t length)
{
    uint8_t i;
    uint32_t crc = 0xffffffff;  // Initial value
    while(length--)
    {
        crc ^= (*data++) << 0;
        for (i = 0; i < 32; ++i)
        {
            if ( crc & 0x80000000 )
                crc = (crc << 1) ^ 0x0000009b;
            else
                crc <<= 1;
        }
    }
    return crc;
}


void main(void)
{
	temp=crc32_mpeg_2(&aDataBuffer, BUFFER_SIZE);
	printf("crc32 value=:%x\r\n",temp);
} 

结果得到结果：

得到的值是0xfff75e7f

不是0xef.

请高手指教，谢谢！

秦天qintian0303

写的程序有问题吧，CRC是不是应该有初始值和标志啊，可以网上找一下

bigbat

不要自己算，有专门的网站可以计算各种CRC，你需要注意CRC初始化的时候，一定要初始化原始寄存器，好像默认是0xFFFF,也可能是0x0，还有就是CRC校验式，以及选择需要的计算和位数。只要这个三个相同就不会错，这个我试验过。

chenbingjy

秦天qintian0303 发表于 2023-6-2 22:45 写的程序有问题吧，CRC是不是应该有初始值和标志啊，可以网上找一下

我写的初始值是0xffffffff,STM32里没明确说明初始值。网上也不好找啊。

chenbingjy

bigbat 发表于 2023-6-3 09:19 不要自己算，有专门的网站可以计算各种CRC，你需要注意CRC初始化的时候，一定要初始化原始寄存器，好像默认 ...

你回答的我不满意。比如我用单片机和上位机通讯，单片机用硬件CRC，上位机你总不能用专门的CRC计算器去计算吧。只能自己找到合适的算法。否则单片机的硬件CRC就没意义了。

damiaa

有CRC32 、CRC16、CRC8 吧

CrcHandle.Init.GeneratingPolynomial = CRC_POLYNOMIAL_8B;

/* The user-defined generating polynomial generates a 8-bit long CRC */

CrcHandle.Init.CRCLength = CRC_POLYLENGTH_8B;

CRC_POLYNOMIAL_32B  

CRC_POLYLENGTH_32B

huo_hu

你这个位数都对不上，硬件是8位软件是32位，32位可以代替8位，但必须每字节校验

除了位数以外，移位方向，计算初值和异或值都会影响结果。

全一样才行，就这些

 

 

huo_hu

计算器可以帮你确认一下算法

chenbingjy

huo_hu 发表于 2023-6-5 08:48 你这个位数都对不上，硬件是8位软件是32位，32位可以代替8位，但必须每字节校验 除了位数以外，移位方向 ...

谢谢！

单片机程序，多项式是8位的，可是数据输入格式是32位的，缺省初始值。

你说的有的因素确实不清楚，程序里也没说。

不知道STM32搞的什么鬼。所以我才发帖子问，看谁知道。

chenbingjy

huo_hu 发表于 2023-6-5 08:54 计算器可以帮你确认一下算法

谢谢！没有那样的计算器呀。这个多项式是自定义的

huo_hu

32位校验的最低8位和8位校验的结果是一样的。

我印象里stm32的多项式的值是不能改的所以没办法适合所有的算法，后来也没再研究

chenbingjy

huo_hu 发表于 2023-6-5 09:11 32位校验的最低8位和8位校验的结果是一样的。 我印象里stm32的多项式的值是不能改的所以没办法适合所有 ...

谢谢！我在网上找了一个可以自定义8位多项式的CRC计算器，可以算出正确的结果。

然后，我用C语言写出了软件计算的程序。

可是还有一个7位的CRC计算程序：
 

#include "main.h"

/** @addtogroup STM32L4xx_HAL_Examples
  * @{
  */

/** @addtogroup CRC_Bytes_Stream_7bit_CRC
  * @{
  */

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define BUFFER_SIZE_5  5  /* CRC7_DATA8_TEST5[] is 5-byte long   */ 
#define BUFFER_SIZE_17 17 /* CRC7_DATA8_TEST17[] is 17-byte long */ 
#define BUFFER_SIZE_1  1  /* CRC7_DATA8_TEST1[] is 1-byte long   */ 
#define BUFFER_SIZE_2  2  /* CRC7_DATA8_TEST2[] is 2-byte long   */ 

/* User-defined polynomial */
//#define CRC_POLYNOMIAL_7B  0x65  /* X^7 + X^6 + X^5 + X^2 + 1,
 //                                  used in Train Communication Network, IEC 60870-5[17] */
#define CRC_POLYNOMIAL_7B  0x65  /* X^7 + X^6 + X^5 + X^2 + 1,*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* CRC handler declaration */
CRC_HandleTypeDef   CrcHandle;

/* Used for storing CRC Value */
__IO uint32_t uwCRCValue = 0;

/* Bytes buffers that will consecutively yield CRCs */
static const uint8_t CRC7_DATA8_TEST5[5]   = {0x12,0x34,0xBA,0x71,0xAD};
static const uint8_t CRC7_DATA8_TEST17[17] = {0x12,0x34,0xBA,0x71,0xAD,
                                              0x11,0x56,0xDC,0x88,0x1B,
                                              0xEE,0x4D,0x82, 0x93,0xA6,
                                              0x7F,0xC3};
static const uint8_t CRC7_DATA8_TEST1[1]   = {0x19};                                                
static const uint8_t CRC7_DATA8_TEST2[2]   = {0xAB,0xCD};

       

/* Expected CRC Values */
/* The 7 LSB bits are the 7-bit long CRC */
uint32_t uwExpectedCRCValue_1 = 0x00000057;    /* First byte stream CRC  */
uint32_t uwExpectedCRCValue_2 = 0x0000006E;    /* Second byte stream CRC */
uint32_t uwExpectedCRCValue_3 = 0x0000004B;    /* Third byte stream CRC  */
uint32_t uwExpectedCRCValue_4 = 0x00000026;    /* Fourth byte stream CRC */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void Error_Handler(void);

/* Private functions ---------------------------------------------------------*/

/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{

  /* STM32L4xx HAL library initialization:
       - Configure the Flash prefetch
       - Systick timer is configured by default as source of time base, but user 
         can eventually implement his proper time base source (a general purpose 
         timer for example or other time source), keeping in mind that Time base 
         duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and 
         handled in milliseconds basis.
       - Set NVIC Group Priority to 4
       - Low Level Initialization
     */
  HAL_Init();
  
  /* Configure the system clock to 120 MHz */
  SystemClock_Config();

  /* Configure LED1 and LED3 */
  BSP_LED_Init(LED1);
  BSP_LED_Init(LED3);


  /****************************************************************************/
  /*                                                                          */
  /*                     CRC peripheral initialization                        */
  /*                                                                          */    
  /****************************************************************************/
    
  CrcHandle.Instance = CRC;

  /* The default polynomial is not used. The one to be used must be defined 
     in CrcHandle.Init.GeneratingPolynomial */  
  CrcHandle.Init.DefaultPolynomialUse    = DEFAULT_POLYNOMIAL_DISABLE;
  
  /* Set the value of the generating polynomial. 
    The one used in that example is the 7-bit long CRC generating
    polynomial X^7 + X^6 + X^5 + X^2 + 1 */
  CrcHandle.Init.GeneratingPolynomial    = CRC_POLYNOMIAL_7B;
  
  /* The user-defined generating polynomial yields a 7-bit long CRC */
  CrcHandle.Init.CRCLength               = CRC_POLYLENGTH_7B;

  /* The default init value is used */
  CrcHandle.Init.DefaultInitValueUse     = DEFAULT_INIT_VALUE_ENABLE;

  /* The input data are not inverted */
  CrcHandle.Init.InputDataInversionMode  = CRC_INPUTDATA_INVERSION_NONE;

  /* The output data are not inverted */
  CrcHandle.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_DISABLE;

  /* The input data are bytes (8-bit long data) */
  CrcHandle.InputDataFormat              = CRC_INPUTDATA_FORMAT_BYTES;

  /* De-initialize the CRC peripheral */
  if (HAL_CRC_DeInit(&CrcHandle) != HAL_OK)
  {
    /* Initialization Error */
    Error_Handler();
  }  

  /* Then, initialize the CRC handle */
  if (HAL_CRC_Init(&CrcHandle) != HAL_OK)
  {
    /* Initialization Error */
    Error_Handler();
  }


  /****************************************************************************/
  /*                                                                          */
  /*         CRC computation of a first bytes stream                          */
  /*                                                                          */    
  /****************************************************************************/

  /* The 7-bit long CRC of a 5-byte buffer is computed. After peripheral initialization, 
     the CRC calculator is initialized with the default value that is 0x7F for 
     a 7-bit CRC.
    
    The computed CRC is stored in uint32_t uwCRCValue. The 7-bit long CRC is made of
    uwCRCValue 7 LSB bits. */

  uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST5, BUFFER_SIZE_5);

  /* Compare the CRC value to the expected one */
  if (uwCRCValue != uwExpectedCRCValue_1)
  {
    /* Wrong CRC value: Turn LED3 on */
    Error_Handler();
  }

  
  /****************************************************************************/
  /*                                                                          */
  /*         CRC computation of a second bytes stream                         */
  /*                                                                          */    
  /****************************************************************************/

  /* The 7-bit long CRC of a 17-byte buffer is computed. The CRC calculator
    is not re-initialized, instead the previously computed CRC is used
    as initial value. */

  uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST17, BUFFER_SIZE_17);

  /* Compare the CRC value to the expected one */
  if (uwCRCValue != uwExpectedCRCValue_2)
  {
    /* Wrong CRC value: Turn LED3 on */
    Error_Handler();
  }


  /****************************************************************************/
  /*                                                                          */
  /*         CRC computation of a single byte                                 */
  /*                                                                          */    
  /****************************************************************************/

  /* The 7-bit long CRC of a 1-byte buffer is computed. The CRC calculator
    is not re-initialized, instead the previously computed CRC is used
    as initial value. */

  uwCRCValue = HAL_CRC_Accumulate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST1, BUFFER_SIZE_1);

  /* Compare the CRC value to the expected one */
  if (uwCRCValue != uwExpectedCRCValue_3)
  {
    /* Wrong CRC value: Turn LED3 on */
    Error_Handler();
  }


  /****************************************************************************/
  /*                                                                          */
  /*         CRC computation of the last bytes stream                         */
  /*                                                                          */    
  /****************************************************************************/

  /* The 7-bit long CRC of a 2-byte buffer is computed. The CRC calculator
    is re-initialized with the default value that is 0x7F for a 7-bit CRC.
    This is done with a call to HAL_CRC_Calculate() instead of 
    HAL_CRC_Accumulate(). */

  uwCRCValue = HAL_CRC_Calculate(&CrcHandle, (uint32_t *)&CRC7_DATA8_TEST2, BUFFER_SIZE_2);

  /* Compare the CRC value to the expected one */
  if (uwCRCValue != uwExpectedCRCValue_4)
  {
    /* Wrong CRC value: Turn LED3 on */
    Error_Handler();
  }
  else
  {
    /* Right CRC value: Turn LED1 on */
    BSP_LED_On(LED1);
  }  


  /* Infinite loop */
  while (1)
  {
  }
}

多项式是7位的，我不知道初始值，也不知道计算时是只计算7位还是8位。如果只计算7位，是计算高7位还是低七位。

我写了个C程序，可是计算结果不对

uint8_t crc7_mpeg_2(uint8_t *data, uint16_t length)
{
    uint8_t i;
    uint32_t crc = 0x7f;  // Initial value
    while(length--)
    {
        crc ^= (*data++) << 0;
        for (i = 0; i < 8; ++i)
        {
            if ( crc & 0x80 )
                crc = (crc << 1) ^ 0x65;
            else
                crc <<= 1;
        }
    }
    return (crc^0x00);
}

 

chenbingjy

huo_hu 发表于 2023-6-5 09:11 32位校验的最低8位和8位校验的结果是一样的。 我印象里stm32的多项式的值是不能改的所以没办法适合所有 ...

关于那个7位的CRC校验，我在网上找了一个查表程序，改了一下，

发现四组数据，有两个是对的，第一个和第四个，0x57,0x26.

第二个和第三个不对：

单片机程序里是0x6e,0x4b,我计算的是0x26,0x2f.

代码：

# include <stdio.h>
# include <string.h>

#define uint8_t unsigned char
#define uint16_t unsigned int
#define uint32_t unsigned  long int

#define TAB_LEN 256
#define ALPHA 0x65

#define BUFFER_SIZE_5  5  /* CRC7_DATA8_TEST5[] is 5-byte long   */ 
#define BUFFER_SIZE_17 17 /* CRC7_DATA8_TEST17[] is 17-byte long */ 
#define BUFFER_SIZE_1  1  /* CRC7_DATA8_TEST1[] is 1-byte long   */ 
#define BUFFER_SIZE_2  2  /* CRC7_DATA8_TEST2[] is 2-byte long   */ 

const uint8_t CRC7_DATA8_TEST5[5]   = {0x12,0x34,0xBA,0x71,0xAD};
const uint8_t CRC7_DATA8_TEST17[17] = {0x12,0x34,0xBA,0x71,0xAD,
                                              0x11,0x56,0xDC,0x88,0x1B,
                                              0xEE,0x4D,0x82, 0x93,0xA6,
                                              0x7F,0xC3};
const uint8_t CRC7_DATA8_TEST1[1]   = {0x19};                                                
const uint8_t CRC7_DATA8_TEST2[2]   = {0xAB,0xCD};
const unsigned char testdat[10] = "0123456789";
       

/* Expected CRC Values */
/* The 7 LSB bits are the 7-bit long CRC */
uint32_t uwExpectedCRCValue_1 = 0x00000057;    /* First byte stream CRC  */
uint32_t uwExpectedCRCValue_2 = 0x0000006E;    /* Second byte stream CRC */
uint32_t uwExpectedCRCValue_3 = 0x0000004B;    /* Third byte stream CRC  */
uint32_t uwExpectedCRCValue_4 = 0x00000026;    /* Fourth byte stream CRC */


unsigned char result;

int table_gen8(unsigned char *buf){
    unsigned int alpha = ALPHA;  //x^7+x^3+1
    int i,j;
    unsigned char tmp;
    for(i=0;i<TAB_LEN;i++){
        tmp = i;
        for(j=0;j<8;j++){
            if(tmp & 0x80)          
                tmp ^= alpha;
            tmp <<= 1;
        }       
        buf[i] = tmp>>1;    /*余数为7bit，计算中用了8bit，结尾多一位0要去掉*/
    }   
    return 0;
}

unsigned char get_crc7(unsigned char start, const unsigned char *buff, int len, unsigned char *table){
    unsigned char accu = start;
    //unsigned char accu = (start<<1);
    unsigned int i= 0;
    for (i=0;  i < len; i++) {
        accu = table[(accu << 1) ^ buff[i]];
        //accu = table[accu^ buff[i]];
    }
    return (accu);
}
int main(void){
    unsigned char data[TAB_LEN] = {0};
    int i,j;
    printf("CRC7 table:\n");
    table_gen8(data);
    for(i=0;i<TAB_LEN/8;i++){
        for(j=0;j<8;j++)
            printf("0x%02x   ",data[i*8+j]);
        printf("\n");
    }
    printf("\n");
    /*Test*/
    
    //result = get_crc7(0, testdat, 10, data);
    //result = get_crc7(0x7f, CRC7_DATA8_TEST5, 5, data);
    //result = get_crc7(0x7f, CRC7_DATA8_TEST17, 17, data);
    //result = get_crc7(0x7f, CRC7_DATA8_TEST1, 1, data);
    result = get_crc7(0x7f, CRC7_DATA8_TEST2, 2, data);
    printf("get_crc7:0x%02x\n",result);
    return 0;
}

 

chenbingjy

我自己研究了一个程序，代码如下：

uint8_t crc7_mmc(uint8_t *data, uint16_t length)
{
    uint8_t i;
    uint8_t crc = 0xFE;     
    while(length--)
    {
        crc ^= *data++;        
        for ( i = 0; i < 8; i++ )
        {
            if ( crc & 0x80 )
                //crc = (crc << 1) ^ 0x65;    
				crc = (crc << 1) ^ 0xCA;      
            else
                crc <<= 1;
        }
    }
    return crc >> 1;
}

也是第一组数据和第四组数据对，第二组和第三组不对，和上面上个算的结果一样。