14：HAL---CRC校验

于 2024-05-11 18:56:47 发布
阅读量554 收藏 22
点赞数 15
分类专栏： HAL库 文章标签： 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74739916/article/details/138625330
版权

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单次校验计算

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "delay.h"
#include "UART.h"
#include <stdarg.h>
#include "stdio.h"
#include "CRC.h"


uint32_t verify[4]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};

int main(void)
{

  
	HAL_Init();                         /* 初始化HAL库 */
  sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  delay_init(72);                     /* 延时初始化 */
  LED_Init();                        /* LED初始化 */
	Uart_Init(115200);
	CRC_Init();
	
	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
	printf("%x\r\n",inspection_data);
	 while (1)
	 {
			
	 }   
}

#include "stm32f1xx_hal.h"


CRC_HandleTypeDef CRC_Handle;

void CRC_Init(void)
{
	CRC_Handle.Instance=CRC;

	HAL_CRC_Init(&CRC_Handle);
}


void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
{

	__HAL_RCC_CRC_CLK_ENABLE();

}

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校验的方式（一次校验一个字）。

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "delay.h"
#include "UART.h"
#include <stdarg.h>
#include "stdio.h"
#include "CRC.h"


uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00,0x01020304};

int main(void)
{

  
	HAL_Init();                         /* 初始化HAL库 */
  sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  delay_init(72);                     /* 延时初始化 */
  LED_Init();                        /* LED初始化 */
	Uart_Init(115200);
	CRC_Init();
	
	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,5);
	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
	printf("单次校验结果=%x\r\n",inspection_data);
	
	
	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[4],1);
	printf("连续校验结果=%x\r\n",Continuous_check);
	 while (1)
	 {
			
	 }   
}

#include "stm32f1xx_hal.h"


CRC_HandleTypeDef CRC_Handle;

void CRC_Init(void)
{
	CRC_Handle.Instance=CRC;

	HAL_CRC_Init(&CRC_Handle);
}


void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
{

	__HAL_RCC_CRC_CLK_ENABLE();

}

C:软件CRC校验计算

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

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "delay.h"
#include "UART.h"
#include <stdarg.h>
#include "stdio.h"
#include "CRC.h"


uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
uint8_t software_verify[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint32_t res;


int main(void)
{

  
	HAL_Init();                         /* 初始化HAL库 */
  sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  delay_init(72);                     /* 延时初始化 */
  LED_Init();                        /* LED初始化 */
	Uart_Init(115200);
	CRC_Init();
	
	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
	printf("硬件单次校验结果=%x\r\n",inspection_data);
	
	
	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
	//HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	printf("硬件连续校验结果=%x\r\n",Continuous_check);
	
	
	uint32_t software_data= CRC32(software_verify,16,0XFFFFFFFF);
	
	printf("软件单次校验结果=%x\r\n",software_data);
	
	res=CRC32(&software_verify[0],4,0XFFFFFFFF);
	res=CRC32(&software_verify[4],4,res);
	res=CRC32(&software_verify[8],4,res);
	
	printf("软件连续校验结果=%x\r\n",CRC32(&software_verify[12],4,res));
	
	
	while (1)
	{
			
	} 

  
}

#include "stm32f1xx_hal.h"


CRC_HandleTypeDef CRC_Handle;

void CRC_Init(void)
{
	CRC_Handle.Instance=CRC;

	HAL_CRC_Init(&CRC_Handle);
}


void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
{

	__HAL_RCC_CRC_CLK_ENABLE();

}

/**
  * @brief  软件CRC32校验计算
  *         
  * @param  data：校验的数据我们一次校验一个字节
  * @param  len:  检验数据的长度 
  * @param  inti:  检验的初值
  * @retval 返回4个字节的校验数据
  */
uint32_t CRC32(uint8_t *data,uint16_t len,uint32_t init)
{
	//^=异或不同为1
	uint32_t poly=0x04C11DB7; //多项式	
	while(len--)
	{	
		//data<<24:因为CRC32返回去的校验值为4个字节;我们校验的是一个字节；
		//所以把他左移3个字节到最高位。3*8=24也就是左移24位。
		init=init^(*data<<24);
		for(uint8_t i=0;i<8;i++)
		{
			if((init&0x80000000))
			{
					init=(init<<1)^poly;		
			}
			else
			{
				init=(init<<1);
			}
		}
		data++;
	}
	return init;
}

D:软件CRC数据反转

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "delay.h"
#include "UART.h"
#include <stdarg.h>
#include "stdio.h"
#include "CRC.h"


uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
uint8_t software_verify[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint32_t res;


int main(void)
{

  
	HAL_Init();                         /* 初始化HAL库 */
  sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  delay_init(72);                     /* 延时初始化 */
  LED_Init();                        /* LED初始化 */
	Uart_Init(115200);
	CRC_Init();
	
	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
	printf("硬件单次校验结果=%x\r\n",inspection_data);
	
	
	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
	//HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	printf("硬件连续校验结果=%x\r\n",Continuous_check);
	
	
	uint32_t software_data= CRC32(software_verify,16,0XFFFFFFFF);
	
	printf("软件单次校验结果=%x\r\n",software_data);
	
	
	//软件的输入反转+输出反转的时候不能使用连续的校验；
	//因为在连续的过程种会不只一次的反转输出的结果（一直调用CRC32函数）
	//只有输入反转的时候可以使用
	
//	res=CRC32(&software_verify[0],4,0XFFFFFFFF);
//	res=CRC32(&software_verify[4],4,res);
//	res=CRC32(&software_verify[8],4,res);
//	//res=CRC32(&software_verify[12],4,res);
//	printf("软件连续校验结果=%x\r\n",CRC32(&software_verify[12],4,res));
	
	
	while (1)
	{
			
	} 

  
}
#include "stm32f1xx_hal.h"

uint8_t Inveruint8(uint8_t data);
uint32_t Inveruint32(uint32_t data);

CRC_HandleTypeDef CRC_Handle;

void CRC_Init(void)
{
	CRC_Handle.Instance=CRC;

	HAL_CRC_Init(&CRC_Handle);
}


void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
{

	__HAL_RCC_CRC_CLK_ENABLE();

}


/**
  * @brief  软件CRC32校验计算
  *         
  * @param  data：校验的数据我们一次校验一个字节
  * @param  len:  检验数据的长度 
  * @param  inti:  检验的初值
  * @retval 返回4个字节的校验数据
  */
uint32_t CRC32(uint8_t *data,uint16_t len,uint32_t init)
{
	//^=异或不同为1
	uint32_t poly=0x04C11DB7; //多项式	
	while(len--)
	{	
		//data<<24:因为CRC32返回去的校验值为4个字节;我们校验的是一个字节；
		//所以把他左移3个字节到最高位。3*8=24也就是左移24位。
		init=init^(Inveruint8(*data)<<24);   //输入反转
		for(uint8_t i=0;i<8;i++)
		{
			if((init&0x80000000))
			{
					init=(init<<1)^poly;		
			}
			else
			{
				init=(init<<1);
			}
		}
		data++;
	}
	return Inveruint32(init);    //输出反转
}



//数据反转
uint8_t Inveruint8(uint8_t data)
{
	uint8_t i;
	uint8_t temp;
	
	temp=0;
	for(i=0;i<8;i++)
	{
		if(data&(1<<i))
		{
			temp|=1<<(7-i);
		}
	}
	return temp;
}


//数据反转
uint32_t Inveruint32(uint32_t data)
{
	uint8_t i;
	uint32_t temp;
	
	temp=0;
	for(i=0;i<32;i++)
	{
		if(data&(1<<i))
		{
			temp|=1<<(31-i);
		}
	}
	return temp;
}

E:软件的CRC16和CRC8

CRC16

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "delay.h"
#include "UART.h"
#include <stdarg.h>
#include "stdio.h"
#include "CRC.h"


uint32_t verify[5]={0x01020304,0x05060708,0x090A0B0C,0x0D0E0F00};
uint8_t software_verify[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint32_t res;


int main(void)
{

  
	HAL_Init();                         /* 初始化HAL库 */
  sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
  delay_init(72);                     /* 延时初始化 */
  LED_Init();                        /* LED初始化 */
	Uart_Init(115200);
	CRC_Init();
	
	uint32_t inspection_data=HAL_CRC_Calculate(&CRC_Handle,verify,4);
	//因为采用的是硬件CRC32的校验，返回的为4个字节。所以必须采用uint32_t 
	//uint32_t 为4个字节。如果使用其他的那么返回值错误，不是4个字节。
	printf("硬件单次校验结果=%x\r\n",inspection_data);
	
	
	HAL_CRC_Calculate(&CRC_Handle,&verify[0],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[1],1);
	HAL_CRC_Accumulate(&CRC_Handle,&verify[2],1);
	//HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	uint32_t Continuous_check=HAL_CRC_Accumulate(&CRC_Handle,&verify[3],1);
	printf("硬件连续校验结果=%x\r\n",Continuous_check);
	
	
	uint16_t software_data= CRC16(software_verify,16,0XFFFF);
	
	printf("软件单次校验结果=%x\r\n",software_data);
	
	
	//软件的输入反转+输出反转的时候不能使用连续的校验；
	//因为在连续的过程种会不只一次的反转输出的结果（一直调用CRC32函数）
	//只有输入反转的时候可以使用
	
//	res=CRC32(&software_verify[0],4,0XFFFFFFFF);
//	res=CRC32(&software_verify[4],4,res);
//	res=CRC32(&software_verify[8],4,res);
//	//res=CRC32(&software_verify[12],4,res);
//	printf("软件连续校验结果=%x\r\n",CRC32(&software_verify[12],4,res));
	
	
	while (1)
	{
			
	} 

  
}

#include "stm32f1xx_hal.h"

uint8_t Inveruint8(uint8_t data);
uint32_t Inveruint32(uint32_t data);
uint16_t Inveruint16(uint16_t data);
CRC_HandleTypeDef CRC_Handle;

void CRC_Init(void)
{
	CRC_Handle.Instance=CRC;

	HAL_CRC_Init(&CRC_Handle);
}


void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
{

	__HAL_RCC_CRC_CLK_ENABLE();

}


/**
  * @brief  软件CRC32校验计算
  *         
  * @param  data：校验的数据我们一次校验一个字节
  * @param  len:  检验数据的长度 
  * @param  inti:  检验的初值
  * @retval 返回4个字节的校验数据
  */
uint32_t CRC32(uint8_t *data,uint16_t len,uint32_t init)
{
	//^=异或不同为1
	uint32_t poly=0x04C11DB7; //多项式	
	while(len--)
	{	
		//data<<24:因为CRC32返回去的校验值为4个字节;我们校验的是一个字节；
		//所以把他左移3个字节到最高位。3*8=24也就是左移24位。
		init=init^(Inveruint8(*data)<<24);   //输入反转
		for(uint8_t i=0;i<8;i++)
		{
			if((init&0x80000000))
			{
					init=(init<<1)^poly;		
			}
			else
			{
				init=(init<<1);
			}
		}
		data++;
	}
	return Inveruint32(init);    //输出反转
}



/**
  * @brief  软件CRC16校验计算
  *         
  * @param  data：校验的数据我们一次校验一个字节
  * @param  len:  检验数据的长度 
  * @param  inti:  检验的初值
  * @retval 返回4个字节的校验数据
  */
uint16_t CRC16(uint8_t *data,uint16_t len,uint16_t init)
{
	//^=异或不同为1
	uint32_t poly=0x8005; //多项式	
	while(len--)
	{	
		
		init=init^(Inveruint8(*data)<<8);   //输入反转
		for(uint8_t i=0;i<8;i++)
		{
			if((init&0x8000))
			{
					init=(init<<1)^poly;		
			}
			else
			{
				init=(init<<1);
			}
		}
		data++;
	}
	return Inveruint16(init);    //输出反转
}



//数据反转---输入
uint8_t Inveruint8(uint8_t data)
{
	uint8_t i;
	uint8_t temp;
	
	temp=0;
	for(i=0;i<8;i++)
	{
		if(data&(1<<i))
		{
			temp|=1<<(7-i);
		}
	}
	return temp;
}





//数据反转----输出
uint32_t Inveruint32(uint32_t data)
{
	uint8_t i;
	uint32_t temp;
	
	temp=0;
	for(i=0;i<32;i++)
	{
		if(data&(1<<i))
		{
			temp|=1<<(31-i);
		}
	}
	return temp;
}



//数据反转
uint16_t Inveruint16(uint16_t data)
{
	uint8_t i;
	uint16_t temp;
	
	temp=0;
	for(i=0;i<16;i++)
	{
		if(data&(1<<i))
		{
			temp|=1<<(15-i);
		}
	}
	return temp;
}

CRC8

/**
  * @brief  软件CRC8校验计算
  *         
  * @param  data：校验的数据我们一次校验一个字节
  * @param  len:  检验数据的长度 
  * @param  inti:  检验的初值
  * @retval 返回4个字节的校验数据
  */
uint8_t CRC8(uint8_t *data,uint16_t len,uint8_t init)
{
	//^=异或不同为1
	uint32_t poly=0x07; //多项式	
	while(len--)
	{	
		
		init=init^(*data<<8);   
		for(uint8_t i=0;i<8;i++)
		{
			if((init&0x80))
			{
					init=(init<<1)^poly;		
			}
			else
			{
				init=(init<<1);
			}
		}
		data++;
	}
	uint8_t software_data= CRC8(software_verify,16,0XFF);
	
	printf("软件单次校验结果=%x\r\n",software_data);

菜鸟-01
关注
  • 15
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【STM32】HAL库-CRC校验demo
05-31
采用STM32F103C8T6单片机，KeilMDK5.32版本 在串口输出数据之前，对数据进行CRC校验，并将数据进行4字节对齐（因为CRC校验是对字进行校验）
C语言CRC-32 STM32格式校验函数
Pegasus的软件博客
04-20 3266
CRC-32校验产生4个字节长度的数据校验码，通过计算得到的校验码和获得的校验码比较，用于验证获得的数据的正确性。不同厂家通过对输入数据前处理和输出数据后处理的方式不同，又产生了不同的厂家校验函数，这里介绍STM32硬件CRC对应格式的CRC-32校验函数。生成多项式为x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + 1。
A8 STM32_HAL库函数 之 CRC通用驱动序所有函数的介绍及使用
最新发布
qq_50808730的博客
04-10 1028
以上就是A8 STM32_HAL库函数 之 CRC通用驱动序所有函数的介绍及使用的内容。有不明白的地方欢迎留言；有建议欢迎留言，我后面编写文档好改进。创作不容，如果文档对您有帮助，记得给个赞。
串口通信+对收到的数据进行crc校验然后发出
03-03
给予stm32g0系列，串口通信+对收到的数据进行crc校验然后发出，hal库
STM32F103单片机HAL库例程-CRC循环冗余校验.rar
03-22
1、嵌入式物联网单片机项目开发实战。例程经过精心编写，简单好用。 2、代码使用KEIL HAL库开发，当前在STM32F103运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 3、软件下载时，请注意keil选择项是jlink还是stlink。 4、技术v：349014857; 5、如果接入其他传感器，请查看发布的其他资料。 6、单片机与模块的接线，在代码当中均有定义，请自行对照。 7、若硬件差异，请根据自身情况适当调整代码，程序仅供参考。 8、代码有注释说明，请耐心阅读。
CRC32校验函数（项目验证）
03-06
CRC32校验函数，用于校验数据传输前后是否发送变化，经项目验证，效果不错，发出来共享，欢迎使用，给个好评。
Stm32——stm32硬件CRC的使用
anmo_moan的博客
02-14 4402
一. 什么是CRC CRC是循环冗余校验，用于检测传输的数据的准确性。比如甲方给乙方发了一条消息，乙方收到消息之后，由CRC校验消息的准确性。 二. 原理 三. 使用HAL库函数HAL_CRC_Calculate直接计算 uint32_t CRC_Value = 0; uint8_t CRC_Result[4] = {0};//定义一个字符数组，用于存储最终CRC结果 CRC_Value = HAL_CRC_Calculate(&hcrc, Data_buffer, 5); CRC_
STM32硬件CRC测试-补充CRC性质
GKoSon的博客
07-17 1392
//测试：故意做一个U8数组 它是10个成员 不是4的倍数 也就是U32以后会丢弃2个 uint8_t acrcBuffer[10] ={0,1,2,3,4,5,6,7,8,9}; uint32_t binlen = 10,bincrc = 0; //CASE1: printf("binlen/4 = %d\r\n",binlen/4);//也就是2啦！ printf("\n\r A...
STM32软硬件CRC测速对比
m0_51095029的博客
12-23 1605
软硬件CRC速度对比
STM32硬件CRC的使用
热门推荐
深圳五月花--老李的森林
01-07 1万+
STM32硬件CRC的使用 STM32硬件的CRC不占用MCU的计算资源，和软件查表计算消耗的存储空间。但其结果与平常使用的CRC不一样，导致很多人还是在用软件计算CRC。 其实结果的差别，只是由于计算方式导致的，调整计算方式以后也可以输出普通计算的结果。 异同 与普通计算方式相同，以CRC32举例，其默认多项式也是 X32 + X26 + X23 + X22 + X16 + X12 + X11 + X10 +X8 + X7 + X5 + X4 + X2+ X +1，但也可以自定义。 计算的初值不同：STM
洋桃电子STM32F407单片机入门教程笔记十一：CRC数据校验功能
m0_61278502的博客
01-10 856
CRC是一种数据校验方式，STM32F407内置硬件CRC校验功能，其本质是一个32位带多项式计算的寄存器，需要计算时只要向CRC寄存器连续写入要计算的数据，寄存器内部将完成计算。读取CRC寄存器就是读取计算结果。
STM32CubeMx配置过程详解
12-19
STM32CubeMx配置过程详解，Cube快速入门，STM32CubeMx 是STM32 系列单片机初始化代码工程生成工具。我们可以用它搜索选择满足我们需求的芯片，用它配置芯片外设引脚和功能，用它配置使用如 LWIP、FAT32、FreeRTOS 等第三方软件系统，还可以用它做功耗评估。STM32CubeMx不仅能生成初始化代码工程，也能生成引脚配置信息的 pdf 和 txt 文档，方便查阅和设计原理图。
CRC校验
weixin_41862804的博客
06-15 1025
1、校验背景 在数据传输过程中，无论传输系统的设计再怎么完美，差错总会存在，这种差错可能会导致在链路上传输的一个或者多个帧被破坏(出现比特差错，0变为1，或者1变为0)，从而接受方接收到错误的数据。为尽量提高接受方收到数据的正确率，在接收方接收数据之前需要对数据进行差错检测，当且仅当检测的结果为正确时接收方才真正收下数据。检测的方式有多种，常见的有奇偶校验、因特网校验和循环冗余校验等。 ...
查表法实现CRC16校验
prochsh的专栏
12-08 1283
[CPP] //CRC高位字节值表 const uint8_t auchCRCHi[] = { 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x8
【STM32】HAL库-CRC校验
熠熠L的博客
05-31 5124
CRC 循环冗余校验(CRC)计算单元是根据固定的生成多项式得到任一32位全字的CRC计算结果。 使用CRC-32(以太网)多项式：0x4C11DB7 CRC计算单元含有1个32位数据寄存器： 对该寄存器进行写操作时，作为输入寄存器，可以输入要进行CRC计算的新数据。 对该寄存器进行读操作时，返回上一次CRC计算的结果。 每一次写入数据寄存器，其计算结果是前一次CRC计算结果和新计算结果的组合(对整个32位字进行CRC计算，而不是逐字节地计算)。 在CRC计算期间会暂停CPU的写操作，因此可以对寄存器
STM32L071 Flash写入的数据进行CRC-CCITT校验
garner99的博客
11-18 1787
Flash写入校验采用采用16位循环冗余校验码CRC-CCITT； /*---------------------------------------------- --功能: 字节查表法求CRC ------------------------------------------------ -*/ unsigned int do_crc(unsigned char *ptr, unsigned int len) // 字节查表法求CRC { unsigned char tda; unsig..
基础实验8- CRC校验实验
weixin_44263904的博客
02-15 425
基础实验8-CRC校验实验 实验目的：掌握硬件CRC的使用方法。 实验现象：下载程序，PC端打开串口助手，选择USB线的端口，波特率为115200，无校验，停止位为1位，HEX模式接收。串口助手接收到CRC文章目录基础实验8-CRC校验实验实验代码 实验代码 int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration-------------------------------------
STM32CubeIDE开发(十)， stm32的CRC计算CubeMX配置及HAL库底层实现分析
技术需要分享
01-03 2621
cubeIDE开发， stm32的CRC计算CubeMX配置及HAL库底层实现分析
hal库16位crc校验
07-28
hal库中提供了对16位crc校验的支持。CRC校验是一种常用的数据校验方法，通过对数据进行一系列的计算和变换，生成一个特定的校验码，用于检测数据在传输或存储过程中是否发生错误。 首先，需要在工程中引入所需的头文件 "stm32f4xx_hal_crc.h"。 接下来，可以通过HAL库提供的函数来进行16位CRC校验。常用的函数有： 1. `HAL_CRC_Init(CRC_HandleTypeDef *hcrc)`：初始化CRC校验器。需要传入一个CRC_HandleTypeDef结构体指针，用于指定需要进行校验的数据的一些参数，例如CRC多项式等。 2. `HAL_CRC_Accumulate(CRC_HandleTypeDef *hcrc, uint32_t *pData, uint32_t Size)`：对指定数据进行CRC累加计算。需要传入一个CRC_HandleTypeDef结构体指针，以及待校验的数据和数据大小。函数会根据传入的数据和配置的CRC多项式，对数据进行计算并累加到CRC校验器的当前值。 3. `HAL_CRC_Calculate(CRC_HandleTypeDef *hcrc, uint32_t *pCRC)`：计算CRC校验结果。需要传入一个CRC_HandleTypeDef结构体指针和一个用于存储校验结果的指针变量。函数会将校验结果保存在指定的变量中。 通过上述函数的组合使用，可以实现16位CRC校验操作。例如，可以先调用`HAL_CRC_Init`函数初始化CRC校验器，然后调用`HAL_CRC_Accumulate`对数据进行累加，最后调用`HAL_CRC_Calculate`计算校验结果。 需要注意的是，具体的CRC多项式、初始值、位反转等参数配置需要根据实际需求进行设置。使用HAL库的16位CRC校验函数，可以方便地进行数据校验，提高数据传输的可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值