1. c语言实现CRC校验
把我知道的说一下：
码流后面加8个0可以用移位得到（码流<<8；）
单次异或运算可以用运算符:^（运算符两边为常数）
由于你校验的是5个字节，且要多次异或运算，所以得借助数组，或其它的数据结果才能完成。
最后问一下你是做硬件的吗
2. C# CRC校验
不知道你这个函数是谁写的，我给你个我写的吧
是CRC16位校验，如果是modbus协议的话，应该是第一位是低位，第二位是高位
public byte[] CRC16_C(byte[] data)
{
byte CRC16Lo;
byte CRC16Hi; //CRC寄存器
byte CL; byte CH; //多项式码&HA001
byte SaveHi; byte SaveLo;
byte[] tmpData;
int I;
int Flag;
CRC16Lo = 0xFF;
CRC16Hi = 0xFF;
CL = 0x01;
CH = 0xA0;
tmpData = data;
for (int i = 0; i < tmpData.Length; i++)
{
CRC16Lo = (byte)(CRC16Lo ^ tmpData[i]); //每一个数据与CRC寄存器进行异或
for (Flag = 0; Flag <= 7; Flag++)
{
SaveHi = CRC16Hi;
SaveLo = CRC16Lo;
CRC16Hi = (byte)(CRC16Hi >> 1); //高位右移一位
CRC16Lo = (byte)(CRC16Lo >> 1); //低位右移一位
if ((SaveHi & 0x01) == 0x01) //如果高位字节最后一位为1
{
CRC16Lo = (byte)(CRC16Lo | 0x80); //则低位字节右移后前面补1
} //否则自动补0
if ((SaveLo & 0x01) == 0x01) //如果LSB为1，则与多项式码进行异或
{
CRC16Hi = (byte)(CRC16Hi ^ CH);
CRC16Lo = (byte)(CRC16Lo ^ CL);
}
}
}
byte[] ReturnData = new byte[2];
ReturnData[0] = CRC16Hi; //CRC高位
ReturnData[1] = CRC16Lo; //CRC低位
return ReturnData;
}
这个你应该知道怎么用吧？
3. 谁内帮我解释一下CRC校验C语言实现的原理，原理好像是把2进制每位分别提取出来与或，但程序不懂啥意思
不是你差，是这程序可读性太差。去读这个程序，不如自己根据需要写一个
4. crc16校验的c语言程序
下面我们以CRC-16为例来说明任意长度数据流的CRC校验码生成过程。我们采用将数据流分成若干个8bit字符，并由低字节到高字节传送的并行方法来求CRC校验码。具体计算过程为：用一个16bit的寄存器来存放CRC校验值，且设定其初值为0x0000；将数据流的第一个8bit与16bit的CRC寄存器的高字节相异或，并将结果存入CRC寄存器高字节；CRC寄存器左移一位，最低1bit补零，同时检查移出的最高1bit，若移出的最高1bit为0，则继续按上述过程左移，若最高1bit为1，则将CRC寄存器中的值与生成多项式码相异或，结果存入CRC寄存器值；继续左移并重复上述处理方法，直到将8bit数据处理完为止，则此时CRC寄存器中的值就是第一个8bit数据对应的CRC校验码；然后将此时CRC寄存器的值作为初值，用同样的处理方法重复上述步骤来处理下一个8bit数据流，直到将所有的8bit字符都处理完后，此刻CRC寄存器中的值即为整个数据流对应的CRC校验码。
下面示出了其计算过程的流程图：
在用C语言编写CRC校验码的实现程序时我们应该注意，生成多项式 对应的十六进制数为0x18005，由于CRC寄存器左移过程中，移出的最高位为1时与 相异或，所以与16bit的CRC寄存器对应的生成多项式的十六进制数可用0x8005表示。下面给出并行处理8bit数据流的C源程序：
unsigned short crc_dsp(unsigned short reg, unsigned char data_crc)
//reg为crc寄存器， data_crc为将要处理的8bit数据流
{
unsigned short msb; //crc寄存器将移出的最高1bit
unsigned short data;
unsigned short gx = 0x8005, i = 0; //i为左移次数， gx为生成多项式
data = (unsigned short)data_crc;
data = data << 8;
reg = reg ^ data;
do
{
msb = reg & 0x8000;
reg = reg << 1;
if(msb == 0x8000)
{
reg = reg ^ gx;
}
i++;
}
while(i < 8);
return (reg);
}
以上为处理每一个8bit数据流的子程序，在计算整个数据流的CRC校验码时，我们只需将CRC_reg的初值置为0x0000，求第一个8bit的CRC值，之后，即可将上次求得的CRC值和本次将要处理的8bit数据作为函数实参传递给上述子程序的形参进行处理即可，最终返回的reg值便是我们所想得到的整个数据流的CRC校验值。
5. c语言 CRC的检验方式 我想问一下。这下面的C语言返回的CRC的值是什么。他有他的公式是怎么样的
CRC又称循环冗余校验，CRC返回的值其实是校验位，校验位分高位和低位。
实际应用时，发送装置计算出CRC值并随数据一同发送给接收装置，接收装置对收到的数据重新计算CRC并与收到的CRC相比较，若两个CRC值不同，则说明数据通讯出现错误。
6. 跪求24位CRC校验的C语言程序，生成多项式g（x）=x^24+x^23+x^6+x^5+x+1
long int GenerateChecksumCRC24_D32(unsigned long ulNumValues,unsigned long *pulData)
{
unsigned long i,ulData,lfsr = 0xFFFFFF;
for (i= 0x0; i < ulNumValues;i++)
{
ulData = pulData[i];
lfsr = CRC24_D32(lfsr,ulData);
}
return lfsr;
}
static unsigned long CRC24_D32(const unsigned long old_CRC, const unsigned long Data)
{
unsigned long D [32];
unsigned long C [24];
unsigned long NewCRC [24];
unsigned long ulCRC24_D32;
unsigned long int f, tmp;
unsigned long int bit_mask = 0x000001;
tmp = 0x000000;
// Convert previous CRC value to binary.
bit_mask = 0x000001;
for (f = 0; f <= 23; f++)
{
C[f] = (old_CRC & bit_mask) >> f;
bit_mask = bit_mask << 1;
}
// Convert data to binary.
bit_mask = 0x000001;
for (f = 0; f <= 31; f++)
{
D[f] = (Data & bit_mask) >> f;
bit_mask = bit_mask << 1;
}
// Calculate new LFSR value.
NewCRC[0] = D[31] ^ D[30] ^ D[29] ^ D[28] ^ D[27] ^ D[26] ^ D[25] ^
D[24] ^ D[23] ^ D[17] ^ D[16] ^ D[15] ^ D[14] ^ D[13] ^
D[12] ^ D[11] ^ D[10] ^ D[9] ^ D[8] ^ D[7] ^ D[6] ^
D[5] ^ D[4] ^ D[3] ^ D[2] ^ D[1] ^ D[0] ^ C[0] ^ C[1] ^
C[2] ^ C[3] ^ C[4] ^ C[5] ^ C[6] ^ C[7] ^ C[8] ^ C[9] ^
C[15] ^ C[16] ^ C[17] ^ C[18] ^ C[19] ^ C[20] ^ C[21] ^
C[22] ^ C[23];
NewCRC[1] = D[23] ^ D[18] ^ D[0] ^ C[10] ^ C[15];
NewCRC[2] = D[24] ^ D[19] ^ D[1] ^ C[11] ^ C[16];
NewCRC[3] = D[25] ^ D[20] ^ D[2] ^ C[12] ^ C[17];
NewCRC[4] = D[26] ^ D[21] ^ D[3] ^ C[13] ^ C[18];
NewCRC[5] = D[31] ^ D[30] ^ D[29] ^ D[28] ^ D[26] ^ D[25] ^ D[24] ^
D[23] ^ D[22] ^ D[17] ^ D[16] ^ D[15] ^ D[14] ^ D[13] ^
D[12] ^ D[11] ^ D[10] ^ D[9] ^ D[8] ^ D[7] ^ D[6] ^
D[5] ^ D[3] ^ D[2] ^ D[1] ^ D[0] ^ C[0] ^ C[1] ^ C[2] ^
C[3] ^ C[4] ^ C[5] ^ C[6] ^ C[7] ^ C[8] ^ C[9] ^ C[14] ^
C[15] ^ C[16] ^ C[17] ^ C[18] ^ C[20] ^ C[21] ^ C[22] ^
C[23];
LFSR代码示例
签名是一个多项式为x24+ x23+ x6
+ x5
+x+1的24位CRC。初始值为0xFFFFFF。
AN-1160
Rev. A | Page 7 of 8
NewCRC[6] = D[28] ^ D[18] ^ D[5] ^ D[0] ^ C[10] ^ C[20];
NewCRC[7] = D[29] ^ D[19] ^ D[6] ^ D[1] ^ C[11] ^ C[21];
NewCRC[8] = D[30] ^ D[20] ^ D[7] ^ D[2] ^ C[12] ^ C[22];
NewCRC[9] = D[31] ^ D[21] ^ D[8] ^ D[3] ^ C[0] ^ C[13] ^ C[23];
NewCRC[10] = D[22] ^ D[9] ^ D[4] ^ C[1] ^ C[14];
NewCRC[11] = D[23] ^ D[10] ^ D[5] ^ C[2] ^ C[15];
NewCRC[12] = D[24] ^ D[11] ^ D[6] ^ C[3] ^ C[16];
NewCRC[13] = D[25] ^ D[12] ^ D[7] ^ C[4] ^ C[17];
NewCRC[14] = D[26] ^ D[13] ^ D[8] ^ C[0] ^ C[5] ^ C[18];
NewCRC[15] = D[27] ^ D[14] ^ D[9] ^ C[1] ^ C[6] ^ C[19];
NewCRC[16] = D[28] ^ D[15] ^ D[10] ^ C[2] ^ C[7] ^ C[20];
NewCRC[17] = D[29] ^ D[16] ^ D[11] ^ C[3] ^ C[8] ^ C[21];
NewCRC[18] = D[30] ^ D[17] ^ D[12] ^ C[4] ^ C[9] ^ C[22];
NewCRC[19] = D[31] ^ D[18] ^ D[13] ^ C[5] ^ C[10] ^ C[23];
NewCRC[20] = D[19] ^ D[14] ^ C[6] ^ C[11];
NewCRC[21] = D[20] ^ D[15] ^ C[7] ^ C[12];
NewCRC[22] = D[21] ^ D[16] ^ C[8] ^ C[13];
NewCRC[23] = D[31] ^ D[30] ^ D[29] ^ D[28] ^ D[27] ^ D[26] ^ D[25] ^
D[24] ^ D[23] ^ D[22] ^ D[16] ^ D[15] ^ D[14] ^ D[13] ^
D[12] ^ D[11] ^ D[10] ^ D[9] ^ D[8] ^ D[7] ^ D[6] ^
D[5] ^ D[4] ^ D[3] ^ D[2] ^ D[1] ^ D[0] ^ C[0] ^ C[1] ^
C[2] ^ C[3] ^ C[4] ^ C[5] ^ C[6] ^ C[7] ^ C[8] ^ C[14] ^
C[15] ^ C[16] ^ C[17] ^ C[18] ^ C[19] ^ C[20] ^ C[21] ^
C[22] ^ C[23];
ulCRC24_D32 = 0;
// LFSR value from binary to hex.
bit_mask = 0x000001;
for (f = 0; f <= 23; f++)
{
ulCRC24_D32 = ulCRC24_D32 + NewCRC[f] * bit_mask;
bit_mask = bit_mask << 1;
}
return(ulCRC24_D32 & 0x00FFFFFF);
}
7. 用C语言实现CRC编码程序
#include <stdio.h>
#include <string.h>
#include "stdlib.h"
unsigned int char2int(char *str)
{
unsigned int count=0, ret=0;
for(count = 0; count<strlen(str);count++)
{
ret = ret<<1;
if('0' != str[count])
{ ret+=1;}
}
return ret;
}
unsigned int getR(char *str)
{
unsigned int c =0 ;
int ret = strlen(str)-1;
for(c=0;c < strlen(str);c++)
{if(str[c] != '0')<br/> {return ret-c;}
}
}
int getRi(unsigned int num)
{
int c =0;
for(;num != 0; c++)
{num = num>>1;}
return c;
}
void CRC(char *scode, char *p, char*g )
{
unsigned int iP = char2int(p);
unsigned int iG = char2int(g);
unsigned int r= getR(g);
unsigned int code = iP << r;
unsigned int yx = code;
for(;getRi(yx) >= getRi(iG);)
{ yx = yx ^ (iG<<(getRi(yx) - getRi(iG)));}
code += yx;
itoa(code,scode,2);
}
void main() //定义主函数
{
char data[8]="" , bds[8]="",code[16]="";
printf("数据：");
scanf("%s", data);
printf("表达式：");
scanf("%s", bds);
CRC(code,data,bds);
printf("编码：%s",code);
}
8. C语言中CRC循环校验的一个程序
while(len--!=0)
这句的len的值循环一次就减少1，先执行len!=0，再执行len--。
当len为0时退出循环。
for(i=0x80;
i!=0;
i/=2)
0x80是十六进制数，也即128
当i!=0时，执行循环体，
然后i=i/2,即i值减半。
9. CRC的C语言的程序
按位计算CRC采用CRC-CCITT多项式，多项式为0x11021，C语言编程时，参与计算为0x1021。当按位计算CRC时，例如计算二进制序列为1001 1010 1010 1111时，将二进制序列数左移16位，即为1001 1010 1010 1111 (0000 0000 0000 0000)，实际上该二进制序列可拆分为1000 0000 0000 0000 (0000 0000 0000 0000) + 000 0000 0000 0000 (0000 0000 0000 0000) + 00 0000 0000 0000 (0000 0000 0000 0000) + 1 0000 0000 0000 (0000 0000 0000 0000) + ……
现在开始分析运算：
<1>对第一个二进制分序列求余数，竖式除法即为0x10000 ^ 0x11021运算，后面的0位保留；
<2>接着对第二个二进制分序列求余数，将第一步运算的余数*2后再和第二个二进制分序列一起对0x11021求余，这一步理解应该没什么问题。如果该分序列为0，无需计算。
<3>对其余的二进制序列求余与上面两步相同。
<4>计算到最后一位时即为整个二进制序列的余数，即为CRC校验码。
该计算方法相当于对每一位计算，运算过程很容易理解，所占内存少，缺点是一位一位计算比较耗时。
下面给出C语言实现方法：
代码如下:
unsigned char test[16] = {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff};
unsigned char len = 16;
void main( void )
{
unsigned long temp = 0;
unsigned int crc;
unsigned char i;
unsigned char *ptr = test;
while( len-- ) {
for(i = 0x80; i != 0; i = i >> 1) {
temp = temp * 2;
if((temp & 0x10000) != 0)
temp = temp ^ 0x11021;
if((*ptr & i) != 0)
temp = temp ^ (0x10000 ^ 0x11021);
}
ptr++;
}
crc = temp;
printf("0x%x ",crc);
}
10. 将下面C语言版的CRC校验改为C#代码版
以下是我的分析，不知是否正确，你参考下1、首先来看你打java代码：crc=(byte)((crc>>1)^0x8c);和 crc=(byte)(crc>>1); 导致这个问题是因为byte的最高位符号位，转换的时候就出错了2、示例代码：package com.test;public class test {public static void main(String[] args) {byte[] ptr = { 1, 1, 1, 1, 1, 1 };byte res = getCrc(ptr);System.out.println();System.out.println((byte)( (1 >> 1) ^ 0x8c ) + ":" +( (1 >> 1) ^ 0x8c ) );}public static byte getCrc(byte[] ptr) {int crc = 0;for (int i = 0; i > 1) ^ 0x8c;} else {crc = crc >> 1;}}}return (byte) crc;}}