CRC校验码

最新推荐文章于 2024-06-24 14:23:41 发布
最新推荐文章于 2024-06-24 14:23:41 发布
阅读量628 收藏 1
点赞数
分类专栏： C++11/17 linux 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neuzhangno/article/details/130529058
版权
C++11/17 同时被 2 个专栏收录
104 篇文章 2 订阅
订阅专栏
linux
47 篇文章 0 订阅
订阅专栏

1. 什么是CRC？

CRC（Cyclic Redundancy Checksum）是一种纠错技术，代表循环冗余校验和。
数据通信领域中最常用的一种差错校验码，其信息字段和校验字段长度可以任意指定，但要求通信双方定义的CRC标准一致。主要用来检测或校验数据传输或者保存后可能出现的错误。它的使用方式可以说明如下图所示：
在数据传输过程中，无论传输系统的设计再怎么完美，差错总会存在，这种差错可能会导致在链路上传输的一个或者多个帧被破坏(出现比特差错，0变为1，或者1变为0)，从而接受方接收到错误的数据。
为尽量提高接受方收到数据的正确率，在接收方接收数据之前需要对数据进行差错检测，当且仅当检测的结果为正确时接收方才真正收下数据。检测的方式有多种，常见的有奇偶校验、因特网校验和循环冗余校验等。

常见的CRC算法

虽然CRC可以任意定义二项式、数据长度等，但没有一个统一的标准的话，就会让整个计算变得非常的麻烦。但实际上，不同的厂家经常采用不同的标准算法，
在这里插入图片描述

代码实现

crc.c
#include "crc.h"
#include <stdio.h>

typedef enum {
	REF_4BIT = 4,
	REF_5BIT = 5,
	REF_6BIT = 6,
	REF_7BIT = 7,
	REF_8BIT = 8,
	REF_16BIT = 16,
	REF_32BIT = 32
}REFLECTED_MODE;

uint32_t ReflectedData(uint32_t data, REFLECTED_MODE mode)
{
	data = ((data & 0xffff0000) >> 16) | ((data & 0x0000ffff) << 16);
	data = ((data & 0xff00ff00) >> 8) | ((data & 0x00ff00ff) << 8);
	data = ((data & 0xf0f0f0f0) >> 4) | ((data & 0x0f0f0f0f) << 4);
	data = ((data & 0xcccccccc) >> 2) | ((data & 0x33333333) << 2);
	data = ((data & 0xaaaaaaaa) >> 1) | ((data & 0x55555555) << 1);

	switch (mode)
	{
	case REF_32BIT:
		return data;
	case REF_16BIT:
		return (data >> 16) & 0xffff;
	case REF_8BIT:
		return (data >> 24) & 0xff;
	case REF_7BIT:
		return (data >> 25) & 0x7f;
	case REF_6BIT:
		return (data >> 26) & 0x7f;
	case REF_5BIT:
		return (data >> 27) & 0x1f;
	case REF_4BIT:
		return (data >> 28) & 0x0f;
	}
	return 0;
}

uint8_t CheckCrc4(uint8_t poly, uint8_t init, bool refIn, bool refOut, uint8_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint8_t i;
	uint8_t crc;

	if (refIn == true)
	{
		crc = init;
		poly = ReflectedData(poly, REF_4BIT);

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x01)
				{
					crc >>= 1;
					crc ^= poly;
				}
				else
				{
					crc >>= 1;
				}
			}
		}

		return crc ^ xorOut;
	}
	else
	{
		crc = init << 4;
		poly <<= 4;

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x80)
				{
					crc <<= 1;
					crc ^= poly;
				}
				else
				{
					crc <<= 1;
				}
			}
		}

		return (crc >> 4) ^ xorOut;
	}
}

uint8_t CheckCrc5(uint8_t poly, uint8_t init, bool refIn, bool refOut, uint8_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint8_t i;
	uint8_t crc;

	if (refIn == true)
	{
		crc = init;
		poly = ReflectedData(poly, REF_5BIT);

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x01)
				{
					crc >>= 1;
					crc ^= poly;
				}
				else
				{
					crc >>= 1;
				}
			}
		}

		return crc ^ xorOut;
	}
	else
	{
		crc = init << 3;
		poly <<= 3;

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x80)
				{
					crc <<= 1;
					crc ^= poly;
				}
				else
				{
					crc <<= 1;
				}
			}
		}

		return (crc >> 3) ^ xorOut;
	}
}

uint8_t CheckCrc6(uint8_t poly, uint8_t init, bool refIn, bool refOut, uint8_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint8_t i;
	uint8_t crc;

	if (refIn == true)
	{
		crc = init;
		poly = ReflectedData(poly, REF_6BIT);

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x01)
				{
					crc >>= 1;
					crc ^= poly;
				}
				else
				{
					crc >>= 1;
				}
			}
		}

		return crc ^ xorOut;
	}
	else
	{
		crc = init << 2;
		poly <<= 2;

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x80)
				{
					crc <<= 1;
					crc ^= poly;
				}
				else
				{
					crc <<= 1;
				}
			}
		}

		return (crc >> 2) ^ xorOut;
	}
}

uint8_t CheckCrc7(uint8_t poly, uint8_t init, bool refIn, bool refOut, uint8_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint8_t i;
	uint8_t crc;

	if (refIn == true)
	{
		crc = init;
		poly = ReflectedData(poly, REF_7BIT);

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x01)
				{
					crc >>= 1;
					crc ^= poly;
				}
				else
				{
					crc >>= 1;
				}
			}
		}

		return crc ^ xorOut;
	}
	else
	{
		crc = init << 1;
		poly <<= 1;

		while (length--)
		{
			crc ^= *buffer++;
			for (i = 0; i < 8; i++)
			{
				if (crc & 0x80)
				{
					crc <<= 1;
					crc ^= poly;
				}
				else
				{
					crc <<= 1;
				}
			}
		}

		return (crc >> 1) ^ xorOut;
	}
}

uint8_t CheckCrc8(uint8_t poly, uint8_t init, bool refIn, bool refOut, uint8_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint32_t i = 0;
	uint8_t crc = init;

	while (length--)
	{
		if (refIn == true)
		{
			crc ^= ReflectedData(*buffer++, REF_8BIT);
		}
		else
		{
			crc ^= *buffer++;
		}

		for (i = 0; i < 8; i++)
		{
			if (crc & 0x80)
			{
				crc <<= 1;
				crc ^= poly;
			}
			else
			{
				crc <<= 1;
			}
		}
	}

	if (refOut == true)
	{
		crc = ReflectedData(crc, REF_8BIT);
	}

	return crc ^ xorOut;
}

uint16_t CheckCrc16(uint16_t poly, uint16_t init, bool refIn, bool refOut, uint16_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint32_t i = 0;
	uint16_t crc = init;

	while (length--)
	{
		if (refIn == true)
		{
			crc ^= ReflectedData(*buffer++, REF_8BIT) << 8;
		}
		else
		{
			crc ^= (*buffer++) << 8;
		}

		for (i = 0; i < 8; i++)
		{
			if (crc & 0x8000)
			{
				crc <<= 1;
				crc ^= poly;
			}
			else
			{
				crc <<= 1;
			}
		}
	}

	if (refOut == true)
	{
		crc = ReflectedData(crc, REF_16BIT);
	}

	return crc ^ xorOut;
}

uint32_t CheckCrc32(uint32_t poly, uint32_t init, bool refIn, bool refOut, uint32_t xorOut,
	const uint8_t *buffer, uint32_t length)
{
	uint32_t i = 0;
	uint32_t crc = init;

	while (length--)
	{
		if (refIn == true)
		{
			crc ^= ReflectedData(*buffer++, REF_8BIT) << 24;
		}
		else
		{
			crc ^= (*buffer++) << 24;
		}

		for (i = 0; i < 8; i++)
		{
			if (crc & 0x80000000)
			{
				crc <<= 1;
				crc ^= poly;
			}
			else
			{
				crc <<= 1;
			}
		}
	}

	if (refOut == true)
	{
		crc = ReflectedData(crc, REF_32BIT);
	}

	return crc ^ xorOut;
}

uint32_t CrcCheck(CRC_Type crcType, const uint8_t *buffer, uint32_t length)
{
	switch (crcType.width)
	{
	case 4:
		return CheckCrc4(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	case 5:
		return CheckCrc5(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	case 6:
		return CheckCrc6(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	case 7:
		return CheckCrc7(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	case 8:
		return CheckCrc8(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	case 16:
		return CheckCrc16(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	case 32:
		return CheckCrc32(crcType.poly, crcType.init, crcType.refIn, crcType.refOut,
			crcType.xorOut, buffer, length);
	}
	return 0;
}


crc.h
#ifndef __CRC_H__
#define __CRC_H__

#include <stdint.h>
#include <stdbool.h>

typedef struct {
	uint8_t width;
	uint32_t poly;
	uint32_t init;
	bool refIn;
	bool refOut;
	uint32_t xorOut;
}CRC_Type;

uint32_t CrcCheck(CRC_Type crcType, const uint8_t *buffer, uint32_t length);

#endif



main.cpp
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include "crc.h"

#define LENGTH	8
const uint8_t data[3][LENGTH] = {
	{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 },
	{ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 },
	{ 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f }};

typedef struct {
	CRC_Type crcType;
	uint32_t result[3];
}CRC_Test;

CRC_Test crc4_ITU = { { 4, 0x03, 0x00, true, true, 0x00 }, { 0x0f, 0x0a, 0x0e } };
CRC_Test crc5_EPC = { { 5, 0x09, 0x09, false, false, 0x00 }, { 0x00, 0x0c, 0x17 } };
CRC_Test crc5_ITU = { { 5, 0x15, 0x00, true, true, 0x00 }, { 0x16, 0x0a, 0x17 } };
CRC_Test crc5_USB = { { 5, 0x05, 0x1f, true, true, 0x1f }, { 0x10, 0x09, 0x17 } };
CRC_Test crc6_ITU = { { 6, 0x03, 0x00, true, true, 0x00 }, { 0x1d, 0x30, 0x00 } };
CRC_Test crc7_MMC = { { 7, 0x09, 0x00, false, false, 0x00 }, { 0x57, 0x30, 0x5b } };
CRC_Test crc8 = { { 8, 0x07, 0x00, false, false, 0x00 }, { 0x3e, 0xe1, 0x36 } };
CRC_Test crc8_ITU = { { 8, 0x07, 0x00, false, false, 0x55 }, { 0x6b, 0xb4, 0x63 } };
CRC_Test crc8_ROHC = { { 8, 0x07, 0xff, true, true, 0x00 }, { 0x6b, 0x78, 0x93 } };
CRC_Test crc8_MAXIM = { { 8, 0x31, 0x00, true, true, 0x00 }, { 0x83, 0x60, 0xa9 } };
CRC_Test crc16_IBM = { { 16, 0x8005, 0x0000, true, true, 0x0000 }, { 0xc4f0, 0x2337, 0xa776 } };
CRC_Test crc16_MAXIM = { { 16, 0x8005, 0x0000, true, true, 0xffff }, { 0x3b0f, 0xdcc8, 0x5889 } };
CRC_Test crc16_USB = { { 16, 0x8005, 0xffff, true, true, 0xffff }, { 0x304f, 0xd788, 0x53c9 } };
CRC_Test crc16_MODBUS = { { 16, 0x8005, 0xffff, true, true, 0x0000 }, { 0xcfb0, 0x2877, 0xac36 } };
CRC_Test crc16_CCITT = { { 16, 0x1021, 0x0000, true, true, 0x0000 }, { 0xeea7, 0xfe7c, 0x7919 } };
CRC_Test crc16_CCITT_FALSE = { { 16, 0x1021, 0xffff, false, false, 0x0000 }, { 0x4792, 0x13a7, 0xb546 } };
CRC_Test crc16_X25 = { { 16, 0x1021, 0xffff, true, true, 0xffff }, { 0x6dd5, 0x7d0f, 0xfa6a } };
CRC_Test crc16_XMODEM = { { 16, 0x1021, 0x0000, false, false, 0x0000 }, { 0x76ac, 0x2299, 0x8478 } };
CRC_Test crc16_DNP = { { 16, 0x3D65, 0x0000, true, true, 0xffff }, { 0x7bda, 0x0535, 0x08c4 } };
CRC_Test crc32 = { { 32, 0x04c11db7, 0xffffffff, true, true, 0xffffffff }, { 0x3fca88c5, 0xe0631a53, 0xa4051a26 } };
CRC_Test crc32_MPEG2 = { { 32, 0x4c11db7, 0xffffffff, false, false, 0x00000000 }, { 0x14dbbdd8, 0x6509b4b6, 0xcb09d294 } };

void CrcTest(CRC_Test crcTest)
{
	uint32_t i;
	for (i = 0; i < 3; i++)
	{
		printf("%08x\t%08x\r\n", CrcCheck(crcTest.crcType, data[i], LENGTH), crcTest.result[i]);
	}
	printf("\r\n");
}

int main(void)
{
	CrcTest(crc4_ITU);
	CrcTest(crc5_EPC);
	CrcTest(crc5_ITU);
	CrcTest(crc5_USB);
	CrcTest(crc6_ITU);
	CrcTest(crc7_MMC);
	CrcTest(crc8);
	CrcTest(crc8_ITU);
	CrcTest(crc8_ROHC);
	CrcTest(crc8_MAXIM);
	CrcTest(crc16_IBM);
	CrcTest(crc16_MAXIM);
	CrcTest(crc16_USB);
	CrcTest(crc16_MODBUS);
	CrcTest(crc16_CCITT);
	CrcTest(crc16_CCITT_FALSE);
	CrcTest(crc16_X25);
	CrcTest(crc16_XMODEM);
	CrcTest(crc16_DNP);
	CrcTest(crc32);
	CrcTest(crc32_MPEG2);

	return 0;
}
星火(star&fire)
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CRC校验码（C#实现）
qq_14853875的博客
12-19 6062
CRC校验（循环冗余校验）小知识 CRC即循环冗余校验码（Cyclic Redundancy Check）：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。 适用规则： CRC-CCITT是一个17位生成多...
CRC校验码（C#）.rar
09-08
自己用的CRC校验高低字节计算，低字节在前，高字节在后，用的查表法。很小的工具。文本框内输入16字节数可以直接计算。可以加空格也可以不加。加空格的话要注意，如果报错的话删除其中一组内的空格就可以了。
C# | 上位机开发新手指南（五）校验算法——CRC
猿长大人
04-04 3074
当我们在进行数据传输时，可能会因为信道噪声、干扰等因素导致数据出现错误，从而影响传输的可靠性和准确性。此时，我们需要一种方法来检测数据是否出现错误，并尽可能快速地发现和纠正错误。CRC（Cyclic Redundancy Check）校验算法就是一种常用的数据校验方法，它通过对数据进行处理生成校验码，从而实现对数据的完整性和准确性进行验证。使用CRC校验的意义在于能够提高数据传输的可靠性，降低数据传输错误率，确保数据的完整性和准确性。在各个领域中，如通信、网络、存储等，CRC校验都得到了广泛的应用。
CRC校验码详解、常见算法实现及代码实例
热门推荐
huanxiajioabu的博客
06-21 2万+
在前面的文章中通过小例子的比喻，简单介绍过什么是CRC，这里再详细的讲解一次。CRC（Cyclic Redundancy Checksum）是一种纠错技术，代表循环冗余校验和。数据通信领域中最常用的一种差错校验码，其信息字段和校验字段长度可以任意指定，但要求通信双方定义的CRC标准一致。主要用来检测或校验数据传输或者保存后可能出现的错误。
C#写CRC16检验码
最新发布
qq_46994975的博客
06-24 405
在C#中编写CRC16校验码通常涉及几个关键步骤，包括选择一个CRC16多项式、设置初始值、处理输入数据以及将结果转换为合适的格式。以下是一个基于C#实现的CRC16校验码生成的示例代码，它使用了CRC16-CCITT标准（多项式，即0x1021），初始值为0xFFFF，并且在结束时对结果取反（这是CRC16-CCITT的一个常见变种）。
C#: CRC8,CRC16,CRC32 校验代码
yutian0606的博客
01-17 1160
说明：CRC即循环冗余校验码（Cyclic Redundancy Check）：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。
c# 如何编写CRC校验算法
zhangzhechun的专栏
03-08 3961
在函数中，先对初始值进行异或操作，然后遍历每个字节，对每个字节和CRC校验值进行异或操作，再按照CRC校验的计算规则进行位移和异或操作，最终得到计算出来的CRC校验值。需要注意的是，CRC校验算法有很多种不同的实现方法和变体，上述代码只是其中一种简单的实现。在实际应用中，应该根据具体的需求和应用场景选择合适的CRC多项式和实现方法。定义一个计算CRC校验值的函数，函数的输入参数为待校验数据的字节数组，输出参数为计算得到的CRC校验值。根据具体的需求和应用场景，选择合适的CRC多项式和初始值。
C# CRC 16 校验码生成
04-17
1.C# CRC 16 校验码生成源码; 2.CRC-16 MODBUG; 3.C#写的CRC16检验算法;
CRC校验源代码（C#）
10-17
1、循环校验码（CRC码）：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。 　　2、生成CRC码的基本原理：任意一个由二进制位串组成的代码都可以和一个系数仅为‘0’和‘1’取值的多项式一一对应。例如：代码1010111对应的多项式为x6+x4+x2+x+1，而多项式为x5+x3+x2+x+1对应的代码101111。 　　3、CRC码集选择的原则：若设码字长度为N，信息字段为K位，校验字段为R位(N=K+R)，则对于CRC码集中的任一码字，存在且仅存在一个R次多项式g(x)，使得 　　V(x)=A(x)g(x)=xRm(x)+r(x); 　　其中: m(x)为K次信息多项式， r(x)为R-1次校验多项式， 　　g(x)称为生成多项式： 　　g(x)=g0+g1x+ g2x2+...+g(R-1)x(R-1)+gRxR 　　发送方通过指定的g(x)产生CRC码字，接收方则通过该g(x)来验证收到的CRC码字。 　　4、CRC校验码软件生成方法： 　　借助于多项式除法，其余数为校验字段。 　　例如：信息字段代码为: 1011001；对应m(x)=x6+x4+x3+1 　　假设生成多项式为：g(x)=x4+x3+1；则对应g(x)的代码为: 11001 　　x4m(x)=x10+x8+x7+x4 对应的代码记为：10110010000； 　　采用多项式除法: 得余数为: 1010 (即校验字段为：1010） 　　发送方：发出的传输字段为: 1 0 1 1 0 0 1 1 0 10 　　信息字段 校验字段 　　接收方：使用相同的生成码进行校验:接收到的字段/生成码（二进制除法） 　　如果能够除尽，则正确，
C#实现CRC校验算法
jackthj的专栏
12-02 1744
C#实现CRC校验算法 2007-06-16 10:06 by l, 2734 visits, 收藏, 编辑 #region CRC校验         ///         /// CRC高位校验码checkCRCHigh         ///         static byte[] ArrayCRCHigh =         {         0x0
CRC校验码生成器（exe文件）
11-14
CRC校验码生成器是实现这一功能的工具，通常以可执行文件（exe文件）的形式存在，用户可以简单地双击运行，对输入的报文进行加密和校验。 CRC的工作原理基于多项式除法，具体步骤如下： 1. **选择生成多项式**：...
C#实现CRC校验算法的源代码
08-13
用C#实现CRC校验的算法，附有源代码！
C#计算CRC16校验码示例
11-08
遇到要做个CRC校验，翻了一堆资料终于看明白了，内有详细注释，不是普通的词典法，是用算法计算出来的CRC，对于CRC16-CCITT，只需替换公式即可 /* CRC16实现原理 * * CRC16 | g(x)=x16+x15+x2+1 | 0x1,80,05 | 1,1000,0000,0000,0101 * * 由于在步骤进行了取反，这里也要把公式反过来 * 0x8005 1000000000000101 * 0xA001 1010000000000001 * * 1.置16位CRC寄存器CRCFull全为1 * 2.数据message[i]一个字节8位与CRCFull异或，结果存在CRCFull（作用是取反） * 3.CRCFull最低位存在CRCLSB，CRCFull右移一位(向低位)，用0填补最高位 * 4.检查原最低位即CRCLSB： * 1：CRCFull与多项式0xA001异或 * 0：重复步骤 * 5.重复步骤和，直到右移8次，处理完整个message[i]字节 * 6.重复步骤到，进行下一个字节8位数据的处理，直到(message.Length) * 7.最后得到的CRC寄存器CRCFull即为此数据的CRC16码 * * * */
C# CRC 校验
01-06
C# crc32校验源码 代码 里面包含有算法，调用方法 方便大家参考使用
CRC校验码计算小工具
04-18
在MODBUS协议中，CRC校验码扮演着至关重要的角色，确保了数据在传输过程中的正确性。 MODBUS协议是一种通用的工业标准通信协议，被广泛应用于PLC（可编程逻辑控制器）和其他自动化设备之间进行数据交换。在MODBUS...
crc校验码计算.pdf
10-25
生成CRC校验码的过程如下： 1. **选择生成多项式**：CRC的核心是生成多项式，它是一个二进制系数的多项式，例如CRC-16的生成多项式为0x1021，而CRC-32的生成多项式为0x104C11DB7。这些多项式决定了校验码的位数和...
CRC校验原理步骤以及CRC校验码的计算.docx
10-25
CRC 校验原理步骤以及CRC校验码的计算 CRC（循环冗余校验码）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附加在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。CRC 校验...
CRC.rar_crc 校验码
09-22
前者可能是一个文档，提供了关于CRC校验码的更详细信息或者源代码的介绍；后者可能是CRC校验码的C++实现源代码。我们将主要讨论CRC校验码的基本原理及其C++实现。 CRC校验的工作原理基于多项式除法。首先，原始数据...
C#CRC检验码ha
ChrisKyrie的博客
10-30 196
private byte[] CRCHi = new byte[256]{0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x...
添加crc校验码matlab
11-22
在Matlab中添加CRC校验码可以通过以下步骤实现： 首先，需要定义一个CRC生成多项式，通常使用标准的CRC-CCITT多项式（0x1021）。 然后，将需要添加校验码的数据按照所选的CRC算法进行计算，得到校验码的数值。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值