devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

14：HAL---CRC校验_hal crc

作者：神奇cpp | 2024-08-11 03:18:48

赞

踩

hal crc

103系列只有一个CRC

前言：

        CRC（Cyclic Redundancy Check），即循环冗余校验，是一种根据网络数据包或电脑文件等数据产生简短固定位数校核码的快速算法，主要用来检测或校核数据传输或者保存后可能出现的错误。CRC校验的工作原理主要基于以下步骤：

  1. 选定一个标准除数（一个K位二进制数据串）。
  2. 在要发送的数据（m位）后面加上K-1位0，然后将这个新数（M+K-1位）以模2除法的方式除以上面这个标准除数，所得到的余数（余数必须比除数少且只少一位，不够就补0）也就是该数据的CRC校验码。
  3. 将这个校验码附在原m位数据后面，构成新的M+K-1位数据，发送给接收端。
  4. 接收端将接收到的数据除以标准除数，如果余数为0则认为数据正确。

        CRC校验被广泛应用于各种通信协议中，如以太网、USB、串口通信协议等，以及存储介质中，如硬盘、光盘等。在数据传输和存储过程中，由于各种原因（如磁场干扰、光盘划伤等），数据可能会发生错误，CRC校验可以有效地检测并纠正这些错误。

        此外，CRC校验还常用于文件传输、数据库和防篡改检测中。在文件传输过程中，发送方会计算文件的CRC校验码，并将其与文件一同发送给接收方。接收方在接收到文件后，重新计算CRC校验码并与接收到的校验码进行比较，以判断文件是否传输正确。在数据库中，每当数据进行插入、更新或删除操作时，会先计算CRC校验码，并将其与数据一同存储在数据库中。在读取数据时，再次计算CRC校验码并与存储的校验码进行比较，以检测数据是否被篡改。在数据加密中，为了防止被黑客篡改，常常会使用CRC校验技术。

        总之，CRC校验是一种非常有效的数据错误检测和纠正技术，在各种数据传输和存储场景中都有广泛的应用。

一：CRC

CRC种类：CRC8，CRC16,CRC32

CRC8:校验结果为1个字节。

CRC16:校验结果为5个字节。

CRC32:校验结果为4个字节。

在我们整个103系列中只有CRC32的硬件校验。

初始值和多项式：2种通信在确定CRC校验种类后，然后就是确定多项式和初值的一致。

对于我们整个103系列的来说这两个都是固定的值。

多项式：

初值：

二：HAL的配置

 

三：代码

A:硬件CRC单次校验计算

  1. #include "stm32f1xx_hal.h"
  2. #include "rcc.h"
  3. #include "led.h"
  4. #include "delay.h"
  5. #include "UART.h"
  6. #include <stdarg.h>
  7. #include "stdio.h"
  8. #include "CRC.h"
  9.  
  10.  
  11. uint32_t verify[4]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
  12.  
  13. int main(void)
  14. {
  15.  
  16.   
  17. 	HAL_Init();                         /* 初始化HAL库 */
  18.   sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  19.   delay_init(72);                     /* 延时初始化 */
  20.   LED_Init();                        /* LED初始化 */
  21. 	Uart_Init(115200);
  22. 	CRC_Init();
  23. 	
  24. 	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
  25. 	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
  26. 	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
  27. 	printf("%x\r\n",inspection_data);
  28. 	 while (1)
  29. 	 {
  30. 			
  31. 	 }   
  32. }
  33.  
  34. #include "stm32f1xx_hal.h"
  35.  
  36.  
  37. CRC_HandleTypeDef CRC_Handle;
  38.  
  39. void CRC_Init(void)
  40. {
  41. 	CRC_Handle.Instance=CRC;
  42.  
  43. 	HAL_CRC_Init(&CRC_Handle);
  44. }
  45.  
  46.  
  47. void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
  48. {
  49.  
  50. 	__HAL_RCC_CRC_CLK_ENABLE();
  51.  
  52. }

HAL_CRC_Calculate()函数使用注意：

第二个参数：是按字节传输的的（一次4个字节），所以数据从传输检验必须为4字节的整数倍。

uint32_t pBuffer[]：这是一个指向要计算CRC的数据的指针。这个数组包含了要进行CRC计算的数据。由于STM32的CRC算法通常是基于32位数据的，所以这里的数组元素类型通常为uint32_t

我们采用uint32_t 类型的变量占用 4 个字节

第三个参数：

  1. uint32_t BufferLength：这个参数指定了pBuffer数组中的元素数量，也就是要计算CRC的数据长度。这个值通常以32位为单位，表示有多少个32位数据需要进行CRC计算。

B：硬件CRC连续计算

        

        当我们的数据量太大的时候，一次性的计算对于我们来说有点困难，或者内存不够。我们采用连续CRC校验的方式（一次校验一个字）。

  1. #include "stm32f1xx_hal.h"
  2. #include "rcc.h"
  3. #include "led.h"
  4. #include "delay.h"
  5. #include "UART.h"
  6. #include <stdarg.h>
  7. #include "stdio.h"
  8. #include "CRC.h"
  9.  
  10.  
  11. uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00,0x01020304};
  12.  
  13. int main(void)
  14. {
  15.  
  16.   
  17. 	HAL_Init();                         /* 初始化HAL库 */
  18.   sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  19.   delay_init(72);                     /* 延时初始化 */
  20.   LED_Init();                        /* LED初始化 */
  21. 	Uart_Init(115200);
  22. 	CRC_Init();
  23. 	
  24. 	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,5);
  25. 	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
  26. 	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
  27. 	printf("单次校验结果=%x\r\n",inspection_data);
  28. 	
  29. 	
  30. 	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
  31. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
  32. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
  33. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  34. 	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[4],1);
  35. 	printf("连续校验结果=%x\r\n",Continuous_check);
  36. 	 while (1)
  37. 	 {
  38. 			
  39. 	 }   
  40. }
  41.  
  42. #include "stm32f1xx_hal.h"
  43.  
  44.  
  45. CRC_HandleTypeDef CRC_Handle;
  46.  
  47. void CRC_Init(void)
  48. {
  49. 	CRC_Handle.Instance=CRC;
  50.  
  51. 	HAL_CRC_Init(&CRC_Handle);
  52. }
  53.  
  54.  
  55. void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
  56. {
  57.  
  58. 	__HAL_RCC_CRC_CLK_ENABLE();
  59.  
  60. }

C:软件CRC校验计算

        软件的CRC校验相对于我们硬件CRC的检验，来说非常灵活，初始值和多项式我们可以自己调节。

  1. #include "stm32f1xx_hal.h"
  2. #include "rcc.h"
  3. #include "led.h"
  4. #include "delay.h"
  5. #include "UART.h"
  6. #include <stdarg.h>
  7. #include "stdio.h"
  8. #include "CRC.h"
  9.  
  10.  
  11. uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
  12. uint8_t software_verify[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  13. uint32_t res;
  14.  
  15.  
  16. int main(void)
  17. {
  18.  
  19.   
  20. 	HAL_Init();                         /* 初始化HAL库 */
  21.   sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  22.   delay_init(72);                     /* 延时初始化 */
  23.   LED_Init();                        /* LED初始化 */
  24. 	Uart_Init(115200);
  25. 	CRC_Init();
  26. 	
  27. 	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
  28. 	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
  29. 	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
  30. 	printf("硬件单次校验结果=%x\r\n",inspection_data);
  31. 	
  32. 	
  33. 	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
  34. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
  35. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
  36. 	//HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  37. 	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  38. 	printf("硬件连续校验结果=%x\r\n",Continuous_check);
  39. 	
  40. 	
  41. 	uint32_t software_data= CRC32(software_verify,16,0XFFFFFFFF);
  42. 	
  43. 	printf("软件单次校验结果=%x\r\n",software_data);
  44. 	
  45. 	res=CRC32(&software_verify[0],4,0XFFFFFFFF);
  46. 	res=CRC32(&software_verify[4],4,res);
  47. 	res=CRC32(&software_verify[8],4,res);
  48. 	
  49. 	printf("软件连续校验结果=%x\r\n",CRC32(&software_verify[12],4,res));
  50. 	
  51. 	
  52. 	while (1)
  53. 	{
  54. 			
  55. 	} 
  56.  
  57.   
  58. }
  59.  
  60. #include "stm32f1xx_hal.h"
  61.  
  62.  
  63. CRC_HandleTypeDef CRC_Handle;
  64.  
  65. void CRC_Init(void)
  66. {
  67. 	CRC_Handle.Instance=CRC;
  68.  
  69. 	HAL_CRC_Init(&CRC_Handle);
  70. }
  71.  
  72.  
  73. void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
  74. {
  75.  
  76. 	__HAL_RCC_CRC_CLK_ENABLE();
  77.  
  78. }
  79.  
  80. /**
  81.   * @brief  软件CRC32校验计算
  82.   *         
  83.   * @param  data：校验的数据我们一次校验一个字节
  84.   * @param  len:  检验数据的长度 
  85.   * @param  inti:  检验的初值
  86.   * @retval 返回4个字节的校验数据
  87.   */
  88. uint32_t CRC32(uint8_t *data,uint16_t len,uint32_t init)
  89. {
  90. 	//^=异或不同为1
  91. 	uint32_t poly=0x04C11DB7; //多项式	
  92. 	while(len--)
  93. 	{	
  94. 		//data<<24:因为CRC32返回去的校验值为4个字节;我们校验的是一个字节；
  95. 		//所以把他左移3个字节到最高位。3*8=24也就是左移24位。
  96. 		init=init^(*data<<24);
  97. 		for(uint8_t i=0;i<8;i++)
  98. 		{
  99. 			if((init&0x80000000))
  100. 			{
  101. 					init=(init<<1)^poly;		
  102. 			}
  103. 			else
  104. 			{
  105. 				init=(init<<1);
  106. 			}
  107. 		}
  108. 		data++;
  109. 	}
  110. 	return init;
  111. }

D:软件CRC数据反转

  1. #include "stm32f1xx_hal.h"
  2. #include "rcc.h"
  3. #include "led.h"
  4. #include "delay.h"
  5. #include "UART.h"
  6. #include <stdarg.h>
  7. #include "stdio.h"
  8. #include "CRC.h"
  9.  
  10.  
  11. uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
  12. uint8_t software_verify[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  13. uint32_t res;
  14.  
  15.  
  16. int main(void)
  17. {
  18.  
  19.   
  20. 	HAL_Init();                         /* 初始化HAL库 */
  21.   sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  22.   delay_init(72);                     /* 延时初始化 */
  23.   LED_Init();                        /* LED初始化 */
  24. 	Uart_Init(115200);
  25. 	CRC_Init();
  26. 	
  27. 	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
  28. 	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
  29. 	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
  30. 	printf("硬件单次校验结果=%x\r\n",inspection_data);
  31. 	
  32. 	
  33. 	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
  34. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
  35. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
  36. 	//HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  37. 	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  38. 	printf("硬件连续校验结果=%x\r\n",Continuous_check);
  39. 	
  40. 	
  41. 	uint32_t software_data= CRC32(software_verify,16,0XFFFFFFFF);
  42. 	
  43. 	printf("软件单次校验结果=%x\r\n",software_data);
  44. 	
  45. 	
  46. 	//软件的输入反转+输出反转的时候不能使用连续的校验；
  47. 	//因为在连续的过程种会不只一次的反转输出的结果（一直调用CRC32函数）
  48. 	//只有输入反转的时候可以使用
  49. 	
  50. //	res=CRC32(&software_verify[0],4,0XFFFFFFFF);
  51. //	res=CRC32(&software_verify[4],4,res);
  52. //	res=CRC32(&software_verify[8],4,res);
  53. //	//res=CRC32(&software_verify[12],4,res);
  54. //	printf("软件连续校验结果=%x\r\n",CRC32(&software_verify[12],4,res));
  55. 	
  56. 	
  57. 	while (1)
  58. 	{
  59. 			
  60. 	} 
  61.  
  62.   
  63. }
  64. #include "stm32f1xx_hal.h"
  65.  
  66. uint8_t Inveruint8(uint8_t data);
  67. uint32_t Inveruint32(uint32_t data);
  68.  
  69. CRC_HandleTypeDef CRC_Handle;
  70.  
  71. void CRC_Init(void)
  72. {
  73. 	CRC_Handle.Instance=CRC;
  74.  
  75. 	HAL_CRC_Init(&CRC_Handle);
  76. }
  77.  
  78.  
  79. void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
  80. {
  81.  
  82. 	__HAL_RCC_CRC_CLK_ENABLE();
  83.  
  84. }
  85.  
  86.  
  87. /**
  88.   * @brief  软件CRC32校验计算
  89.   *         
  90.   * @param  data：校验的数据我们一次校验一个字节
  91.   * @param  len:  检验数据的长度 
  92.   * @param  inti:  检验的初值
  93.   * @retval 返回4个字节的校验数据
  94.   */
  95. uint32_t CRC32(uint8_t *data,uint16_t len,uint32_t init)
  96. {
  97. 	//^=异或不同为1
  98. 	uint32_t poly=0x04C11DB7; //多项式	
  99. 	while(len--)
  100. 	{	
  101. 		//data<<24:因为CRC32返回去的校验值为4个字节;我们校验的是一个字节；
  102. 		//所以把他左移3个字节到最高位。3*8=24也就是左移24位。
  103. 		init=init^(Inveruint8(*data)<<24);   //输入反转
  104. 		for(uint8_t i=0;i<8;i++)
  105. 		{
  106. 			if((init&0x80000000))
  107. 			{
  108. 					init=(init<<1)^poly;		
  109. 			}
  110. 			else
  111. 			{
  112. 				init=(init<<1);
  113. 			}
  114. 		}
  115. 		data++;
  116. 	}
  117. 	return Inveruint32(init);    //输出反转
  118. }
  119.  
  120.  
  121.  
  122. //数据反转
  123. uint8_t Inveruint8(uint8_t data)
  124. {
  125. 	uint8_t i;
  126. 	uint8_t temp;
  127. 	
  128. 	temp=0;
  129. 	for(i=0;i<8;i++)
  130. 	{
  131. 		if(data&(1<<i))
  132. 		{
  133. 			temp|=1<<(7-i);
  134. 		}
  135. 	}
  136. 	return temp;
  137. }
  138.  
  139.  
  140. //数据反转
  141. uint32_t Inveruint32(uint32_t data)
  142. {
  143. 	uint8_t i;
  144. 	uint32_t temp;
  145. 	
  146. 	temp=0;
  147. 	for(i=0;i<32;i++)
  148. 	{
  149. 		if(data&(1<<i))
  150. 		{
  151. 			temp|=1<<(31-i);
  152. 		}
  153. 	}
  154. 	return temp;
  155. }

E:软件的CRC16和CRC8

CRC16

  1. #include "stm32f1xx_hal.h"
  2. #include "rcc.h"
  3. #include "led.h"
  4. #include "delay.h"
  5. #include "UART.h"
  6. #include <stdarg.h>
  7. #include "stdio.h"
  8. #include "CRC.h"
  9.  
  10.  
  11. uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
  12. uint8_t software_verify[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  13. uint32_t res;
  14.  
  15.  
  16. int main(void)
  17. {
  18.  
  19.   
  20. 	HAL_Init();                         /* 初始化HAL库 */
  21.   sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  22.   delay_init(72);                     /* 延时初始化 */
  23.   LED_Init();                        /* LED初始化 */
  24. 	Uart_Init(115200);
  25. 	CRC_Init();
  26. 	
  27. 	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
  28. 	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
  29. 	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
  30. 	printf("硬件单次校验结果=%x\r\n",inspection_data);
  31. 	
  32. 	
  33. 	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
  34. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
  35. 	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
  36. 	//HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  37. 	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
  38. 	printf("硬件连续校验结果=%x\r\n",Continuous_check);
  39. 	
  40. 	
  41. 	uint16_t software_data= CRC16(software_verify,16,0XFFFF);
  42. 	
  43. 	printf("软件单次校验结果=%x\r\n",software_data);
  44. 	
  45. 	
  46. 	//软件的输入反转+输出反转的时候不能使用连续的校验；
  47. 	//因为在连续的过程种会不只一次的反转输出的结果（一直调用CRC32函数）
  48. 	//只有输入反转的时候可以使用
  49. 	
  50. //	res=CRC32(&software_verify[0],4,0XFFFFFFFF);
  51. //	res=CRC32(&software_verify[4],4,res);
  52. //	res=CRC32(&software_verify[8],4,res);
  53. //	//res=CRC32(&software_verify[12],4,res);
  54. //	printf("软件连续校验结果=%x\r\n",CRC32(&software_verify[12],4,res));
  55. 	
  56. 	
  57. 	while (1)
  58. 	{
  59. 			
  60. 	} 
  61.  
  62.   
  63. }
  64.  
  65. #include "stm32f1xx_hal.h"
  66.  
  67. uint8_t Inveruint8(uint8_t data);
  68. uint32_t Inveruint32(uint32_t data);
  69. uint16_t Inveruint16(uint16_t data);
  70. CRC_HandleTypeDef CRC_Handle;
  71.  
  72. void CRC_Init(void)
  73. {
  74. 	CRC_Handle.Instance=CRC;
  75.  
  76. 	HAL_CRC_Init(&CRC_Handle);
  77. }
  78.  
  79.  
  80. void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
  81. {
  82.  
  83. 	__HAL_RCC_CRC_CLK_ENABLE();
  84.  
  85. }
  86.  
  87.  
  88. /**
  89.   * @brief  软件CRC32校验计算
  90.   *         
  91.   * @param  data：校验的数据我们一次校验一个字节
  92.   * @param  len:  检验数据的长度 
  93.   * @param  inti:  检验的初值
  94.   * @retval 返回4个字节的校验数据
  95.   */
  96. uint32_t CRC32(uint8_t *data,uint16_t len,uint32_t init)
  97. {
  98. 	//^=异或不同为1
  99. 	uint32_t poly=0x04C11DB7; //多项式	
  100. 	while(len--)
  101. 	{	
  102. 		//data<<24:因为CRC32返回去的校验值为4个字节;我们校验的是一个字节；
  103. 		//所以把他左移3个字节到最高位。3*8=24也就是左移24位。
  104. 		init=init^(Inveruint8(*data)<<24);   //输入反转
  105. 		for(uint8_t i=0;i<8;i++)
  106. 		{
  107. 			if((init&0x80000000))
  108. 			{
  109. 					init=(init<<1)^poly;		
  110. 			}
  111. 			else
  112. 			{
  113. 				init=(init<<1);
  114. 			}
  115. 		}
  116. 		data++;
  117. 	}
  118. 	return Inveruint32(init);    //输出反转
  119. }
  120.  
  121.  
  122.  
  123. /**
  124.   * @brief  软件CRC16校验计算
  125.   *         
  126.   * @param  data：校验的数据我们一次校验一个字节
  127.   * @param  len:  检验数据的长度 
  128.   * @param  inti:  检验的初值
  129.   * @retval 返回4个字节的校验数据
  130.   */
  131. uint16_t CRC16(uint8_t *data,uint16_t len,uint16_t init)
  132. {
  133. 	//^=异或不同为1
  134. 	uint32_t poly=0x8005; //多项式	
  135. 	while(len--)
  136. 	{	
  137. 		
  138. 		init=init^(Inveruint8(*data)<<8);   //输入反转
  139. 		for(uint8_t i=0;i<8;i++)
  140. 		{
  141. 			if((init&0x8000))
  142. 			{
  143. 					init=(init<<1)^poly;		
  144. 			}
  145. 			else
  146. 			{
  147. 				init=(init<<1);
  148. 			}
  149. 		}
  150. 		data++;
  151. 	}
  152. 	return Inveruint16(init);    //输出反转
  153. }
  154.  
  155.  
  156.  
  157. //数据反转---输入
  158. uint8_t Inveruint8(uint8_t data)
  159. {
  160. 	uint8_t i;
  161. 	uint8_t temp;
  162. 	
  163. 	temp=0;
  164. 	for(i=0;i<8;i++)
  165. 	{
  166. 		if(data&(1<<i))
  167. 		{
  168. 			temp|=1<<(7-i);
  169. 		}
  170. 	}
  171. 	return temp;
  172. }
  173.  
  174.  
  175.  
  176.  
  177.  
  178. //数据反转----输出
  179. uint32_t Inveruint32(uint32_t data)
  180. {
  181. 	uint8_t i;
  182. 	uint32_t temp;
  183. 	
  184. 	temp=0;
  185. 	for(i=0;i<32;i++)
  186. 	{
  187. 		if(data&(1<<i))
  188. 		{
  189. 			temp|=1<<(31-i);
  190. 		}
  191. 	}
  192. 	return temp;
  193. }
  194.  
  195.  
  196.  
  197. //数据反转
  198. uint16_t Inveruint16(uint16_t data)
  199. {
  200. 	uint8_t i;
  201. 	uint16_t temp;
  202. 	
  203. 	temp=0;
  204. 	for(i=0;i<16;i++)
  205. 	{
  206. 		if(data&(1<<i))
  207. 		{
  208. 			temp|=1<<(15-i);
  209. 		}
  210. 	}
  211. 	return temp;
  212. }

CRC8

  1. /**
  2.   * @brief  软件CRC8校验计算
  3.   *         
  4.   * @param  data：校验的数据我们一次校验一个字节
  5.   * @param  len:  检验数据的长度 
  6.   * @param  inti:  检验的初值
  7.   * @retval 返回4个字节的校验数据
  8.   */
  9. uint8_t CRC8(uint8_t *data,uint16_t len,uint8_t init)
  10. {
  11. 	//^=异或不同为1
  12. 	uint32_t poly=0x07; //多项式	
  13. 	while(len--)
  14. 	{	
  15. 		
  16. 		init=init^(*data<<8);   
  17. 		for(uint8_t i=0;i<8;i++)
  18. 		{
  19. 			if((init&0x80))
  20. 			{
  21. 					init=(init<<1)^poly;		
  22. 			}
  23. 			else
  24. 			{
  25. 				init=(init<<1);
  26. 			}
  27. 		}
  28. 		data++;
  29. 	}
  30. 	uint8_t software_data= CRC8(software_verify,16,0XFF);
  31. 	
  32. 	printf("软件单次校验结果=%x\r\n",software_data);

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/961915
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号