CRC算法原理及C语言实现
摘 要 本文从理论上推导出CRC算法实现原理,给出三种分别适应不同计算机或微控制器硬件环境的C语言程序。读者更能根据本算法原理,用不同的语言编写出独特风格更加实用的CRC计算程序。
关键词 CRC 算法 C语言
1 引言
循环冗余码CRC检验技术广泛应用于测控及通信领域。CRC计算可以靠专用的硬件来实现,但是对于低成本的微控制器系统,在没有硬件支持下实现CRC检验,关键的问题就是如何通过软件来完成CRC计算,也就是CRC算法的问题。
这里将提供三种算法,它们稍有不同,一种适用于程序空间十分苛刻但CRC计算速度要求不高的微控制器系统,另一种适用于程序空间较大且CRC计算速度要求较高的计算机或微控制器系统,最后一种是适用于程序空间不太大,且CRC计算速度又不可以太慢的微控制器系统。
2 CRC简介
CRC校验的基本思想是利用线性编码理论,在发送端根据要传送的k位二进制码序列,以一定的规则产生一个校验用的监督码（既CRC码）r位,并附在信息后边,构成一个新的二进制码序列数共(k+r)位,最后发送出去。在接收端,则根据信息码和CRC码之间所遵循的规则进行检验,以确定传送中是否出错。
16位的CRC码产生的规则是先将要发送的二进制序列数左移16位（既乘以 ）后,再除以一个多项式,最后所得到的余数既是CRC码,如式（2-1）式所示,其中B(X)表示n位的二进制序列数,G(X)为多项式,Q(X)为整数,R(X)是余数（既CRC码）。
（2-1）
求CRC码所采用模2加减运算法则,既是不带进位和借位的按位加减,这种加减运算实际上就是逻辑上的异或运算,加法和减法等价,乘法和除法运算与普通代数式的乘除法运算是一样,符合同样的规律。生成CRC码的多项式如下,其中CRC-16和CRC-CCITT产生16位的CRC码,而CRC-32则产生的是32位的CRC码。本文不讨论32位的CRC算法,有兴趣的朋友可以根据本文的思路自己去推导计算方法。
CRC-16：（美国二进制同步系统中采用）
CRC-CCITT：（由欧洲CCITT推荐）
CRC-32：
接收方将接收到的二进制序列数（包括信息码和CRC码）除以多项式,如果余数为0,则说明传输中无错误发生,否则说明传输有误,关于其原理这里不再多述。用软件计算CRC码时,接收方可以将接收到的信息码求CRC码,比较结果和接收到的CRC码是否相同。
3 按位计算CRC
对于一个二进制序列数可以表示为式(3-1):
(3-1)
求此二进制序列数的CRC码时,先乘以 后（既左移16位）,再除以多项式G(X),所得的余数既是所要求的CRC码。如式(3-2)所示：
(3-2)
可以设： (3-3)
其中 为整数, 为16位二进制余数。将式(3-3)代入式(3-2)得：
(3-4)
再设： (3-5)
其中 为整数, 为16位二进制余数,将式(3-5)代入式(3-4),如上类推,最后得到：
(3-6)
根据CRC的定义,很显然,十六位二进制数 既是我们要求的CRC码。
式(3-5)是编程计算CRC的关键,它说明计算本位后的CRC码等于上一位CRC码乘以2后除以多项式,所得的余数再加上本位值除以多项式所得的余数。由此不难理解下面求CRC码的C语言程序。*ptr指向发送缓冲区的首字节,len是要发送的总字节数,0x1021与多项式有关。
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned char i;
unsigned int crc=0;
while(len--!=0) {
for(i=0x80; i!=0; i/=2) {
if((crc&;0x8000)!=0) {crc*=2; crc^=0x1021;} /* 余式CRC乘以2再求CRC */
else crc*=2;
if((*ptr&;i)!=0) crc^=0x1021; /* 再加上本位的CRC */
}
ptr++;
}
return(crc);
}
按位计算CRC虽然代码简单,所占用的内存比较少,但其最大的缺点就是一位一位地计算会占用很多的处理器处理时间,尤其在高速通讯的场合,这个缺点更是不可容忍。因此下面再介绍一种按字节查表快速计算CRC的方法。
4 按字节计算CRC
不难理解,对于一个二进制序列数可以按字节表示为式(4-1),其中 为一个字节(共8位)。
(4-1)
求此二进制序列数的CRC码时,先乘以 后（既左移16位）,再除以多项式G(X),所得的余数既是所要求的CRC码。如式(4-2)所示：
（4-2）
可以设： (4-3)
其中 为整数, 为16位二进制余数。将式(4-3)代入式(4-2)得：
（4-4）
因为：
（4-5）
其中 是 的高八位, 是 的低八位。将式（4-5）代入式（4-4）,经整理后得：
（4-6）
再设： (4-7)
其中 为整数, 为16位二进制余数。将式(4-7)代入式(4-6),如上类推,最后得：
(4-8)
很显然,十六位二进制数 既是我们要求的CRC码。
式(4-7)是编写按字节计算CRC程序的关键,它说明计算本字节后的CRC码等于上一字节余式CRC码的低8位左移8位后,再加上上一字节CRC右移8位（也既取高8位）和本字节之和后所求得的CRC码,如果我们把8位二进制序列数的CRC全部计算出来,放如一个表里,采用查表法,可以大大提高计算速度。由此不难理解下面按字节求CRC码的C语言程序。*ptr指向发送缓冲区的首字节,len是要发送的总字节数,CRC余式表是按0x11021多项式求出的。
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[256]={ /* CRC余式表 */
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x 1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
crc=0;
while(len--!=0) {
da=(uchar) (crc/256); /* 以8位二进制数的形式暂存CRC的高8位 */
crc<<=8; /* 左移8位,相当于CRC的低8位乘以 */
crc^=crc_ta[da^*ptr]; /* 高8位和当前字节相加后再查表求CRC ,再加上以前的CRC */
ptr++;
}
return(crc);
}
很显然,按字节求CRC时,由于采用了查表法,大大提高了计算速度。但对于广泛运用的8位微处理器,代码空间有限,对于要求256个CRC余式表（共512字节的内存）已经显得捉襟见肘了,但CRC的计算速度又不可以太慢,因此再介绍下面一种按半字节求CRC的算法。
5 按半字节计算CRC
同样道理,对于一个二进制序列数可以按字节表示为式(5-1),其中 为半个字节(共4位)。
(5-1)
求此二进制序列数的CRC码时,先乘以 后（既左移16位）,再除以多项式G(X),所得的余数既是所要求的CRC码。如式(4-2)所示：
（5-2）
可以设： (5-3)
其中 为整数, 为16位二进制余数。将式(5-3)代入式(5-2)得：
（5-4）
因为：
（5-5）
其中 是 的高4位, 是 的低12位。将式（5-5）代入式（5-4）,经整理后得：
（5-6）
再设： (5-7)
其中 为整数, 为16位二进制余数。将式(5-7)代入式(5-6),如上类推,最后得：
(5-8)
很显然,十六位二进制数 既是我们要求的CRC码。
式(5-7)是编写按字节计算CRC程序的关键,它说明计算本字节后的CRC码等于上一字节CRC码的低12位左移4位后,再加上上一字节余式CRC右移4位（也既取高4位）和本字节之和后所求得的CRC码,如果我们把4位二进制序列数的CRC全部计算出来,放在一个表里,采用查表法,每个字节算两次（半字节算一次）,可以在速度和内存空间取得均衡。由此不难理解下面按半字节求CRC码的C语言程序。*ptr指向发送缓冲区的首字节,len是要发送的总字节数,CRC余式表是按0x11021多项式求出的。
unsigned cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[16]={ /* CRC余式表 */
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
}
crc=0;
while(len--!=0) {
da=((uchar)(crc/256))/16; /* 暂存CRC的高四位 */
crc<<=4; /* CRC右移4位,相当于取CRC的低12位）*/
crc^=crc_ta[da^(*ptr/16)]; /* CRC的高4位和本字节的前半字节相加后查表计算CRC,
然后加上上一次CRC的余数 */
da=((uchar)(crc/256))/16; /* 暂存CRC的高4位 */
crc<<=4; /* CRC右移4位, 相当于CRC的低12位） */
crc^=crc_ta[da^(*ptr&;0x0f)]; /* CRC的高4位和本字节的后半字节相加后查表计算CRC,
然后再加上上一次CRC的余数 */
ptr++;
}
return(crc);
}
⑵ 单片机 用c语言编写 modbus rtu 通讯怎么写啊 主要是crc 校验部分不知道怎么写 怎么把一窜字符进行CRC计算
我刚刚写好.跟PLC连接测试过,可以的.
/***************************************************************
CRC计算方法
1．预置1个16位的寄存器为十六进制FFFF（即全为1）；称此寄存器为CRC寄存器；
2．把第一个8位二进制数据（既通讯信息帧的第一个字节）与16位的CRC寄存器的低
8位相异或，把结果放于CRC寄存器；
3．把CRC寄存器的内容右移一位（朝低位）用0填补最高位，并检查右移后的移出位；
4．如果移出位为0：重复第3步（再次右移一位）；
如果移出位为1：CRC寄存器与多项式A001（1010 0000 0000 0001）进行异或；
5．重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理；
6．重复步骤2到步骤5，进行通讯信息帧下一个字节的处理；
7．将该通讯信息帧所有字节按上述步骤计算完成后，得到的16位CRC；
*****************************************************************/
/****************************************************************************
名称: UART_CRC16_Work()
说明: CRC16校验程序
参数: *CRC_Buf:数据地址
CRC_Leni:数据长度
返回: CRC_Sumx:校验值
*****************************************************************************/
unsigned int UART_CRC16_Work(unsigned char *CRC_Buf,unsigned char CRC_Leni)
{
unsigned char i,j;
unsigned int CRC_Sumx;
CRC_Sumx=0xFFFF;
for(i=0;i<CRC_Leni;i++)
{
CRC_Sumx^=*(CRC_Buf+i);//异或
for(j=0;j<8;j++)
{
if(CRC_Sumx & 0x01)
{
CRC_Sumx>>=1;
CRC_Sumx^=0xA001;
}
else
{
CRC_Sumx>>=1;
}
}
}
return (CRC_Sumx);
}
⑶ CRC验证可以用在单片机里吗
可以是可以，不过这段程序在8位的51单片机里直接编译的话效率太低。
一般都是用等价8位查表法来实现CRC16的。
⑷ DS18B20 的CRC校验时怎么回事
CRC是序列号的校验码 用来验证序列号对不对的。序列号一般是没标的要自己读。给你个读序列号的程序改下端口就能用：
#include <reg51.h>
#include <intrins.h>
#define uchar unsigned char
#define uint unsigned int
sbit DQ = P2^0; //定义DS18B20端口DQ
sbit BEEP=P3^7 ; //蜂鸣器驱动线
bit presence ;
sbit LCD_RS = P2^6;
sbit LCD_RW = P2^5;
sbit LCD_EN = P2^4;
uchar code cdis1[ ] = {" DS18B20 OK "};
uchar code cdis2[ ] = {" "};
uchar code cdis3[ ] = {" DS18B20 ERR0R "};
uchar code cdis4[ ] = {" PLEASE CHECK "};
unsigned char data display[2] = {0x00,0x00};
unsigned char data RomCode[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char Temp;
unsigned char crc;
void beep();
#define delayNOP(); {_nop_();_nop_();_nop_();_nop_();};
/*******************************************************************/
void delay1(int ms)
{
unsigned char y;
while(ms--)
{
for(y = 0; y<250; y++)
{
_nop_();
_nop_();
_nop_();
_nop_();
}
}
}
/******************************************************************/
/* */
/*检查LCD忙状态 */
/*lcd_busy为1时，忙，等待。lcd-busy为0时,闲，可写指令与数据。 */
/* */
/******************************************************************/
bit lcd_busy()
{
bit result;
LCD_RS = 0;
LCD_RW = 1;
LCD_EN = 1;
delayNOP();
result = (bit)(P0&0x80);
LCD_EN = 0;
return(result);
}
/*******************************************************************/
/* */
/*写指令数据到LCD */
/*RS=L，RW=L，E=高脉冲，D0-D7=指令码。 */
/* */
/*******************************************************************/
void lcd_wcmd(uchar cmd)
{
while(lcd_busy());
LCD_RS = 0;
LCD_RW = 0;
LCD_EN = 0;
_nop_();
_nop_();
P0 = cmd;
delayNOP();
LCD_EN = 1;
delayNOP();
LCD_EN = 0;
}
/*******************************************************************/
/* */
/*写显示数据到LCD */
/*RS=H，RW=L，E=高脉冲，D0-D7=数据。 */
/* */
/*******************************************************************/
void lcd_wdat(uchar dat)
{
while(lcd_busy());
LCD_RS = 1;
LCD_RW = 0;
LCD_EN = 0;
P0 = dat;
delayNOP();
LCD_EN = 1;
delayNOP();
LCD_EN = 0;
}
/*******************************************************************/
/* */
/* LCD初始化设定 */
/* */
/*******************************************************************/
void lcd_init()
{
delay1(15);
lcd_wcmd(0x01); //清除LCD的显示内容
lcd_wcmd(0x38); //16*2显示，5*7点阵，8位数据
delay1(5);
lcd_wcmd(0x38);
delay1(5);
lcd_wcmd(0x38);
delay1(5);
lcd_wcmd(0x0c); //显示开，关光标
delay1(5);
lcd_wcmd(0x06); //移动光标
delay1(5);
lcd_wcmd(0x01); //清除LCD的显示内容
delay1(5);
}
/*******************************************************************/
/* */
/* 设定显示位置 */
/* */
/*******************************************************************/
void lcd_pos(uchar pos)
{
lcd_wcmd(pos | 0x80); //数据指针=80+地址变量
}
/*******************************************************************/
/* */
/*us级延时函数 */
/* */
/*******************************************************************/
void Delay(unsigned int num)
{
while( --num );
}
/*******************************************************************/
/* */
/*初始化ds1820 */
/* */
/*******************************************************************/
Init_DS18B20(void)
{
DQ = 1; //DQ复位
Delay(8); //稍做延时
DQ = 0; //将DQ拉低
Delay(90); //精确延时 大于 480us
DQ = 1; //拉高总线
Delay(8);
presence = DQ; //读取存在信号
Delay(100);
DQ = 1;
return(presence); //返回信号，0=presence,1= no presence
}
/*******************************************************************/
/* */
/* 读一位（bit） */
/* */
/*******************************************************************/
uchar read_bit(void)
{
unsigned char i;
DQ = 0; //将DQ 拉低开始读时间隙
DQ = 1; // then return high
for (i=0; i<3; i++); // 延时15μs
return(DQ); // 返回 DQ 线上的电平值
}
/*******************************************************************/
/* */
/* 读一个字节 */
/* */
/*******************************************************************/
ReadOneChar(void)
{
unsigned char i = 0;
unsigned char dat = 0;
//for (i = 8; i > 0; i--)
// {
// read_bit();
// DQ = 0; // 给脉冲信号
// dat >>= 1;
// DQ = 1; // 给脉冲信号
for (i=0;i<8;i++)
{ // 读取字节，每次读取一个字节
if(read_bit()) dat|=0x01<<i; // 然后将其左移
// if(DQ)
// dat |= 0x80;
Delay(4);
}
return (dat);
}
/*******************************************************************/
/* */
/* 写一位 */
/* */
/*******************************************************************/
void write_bit(char bitval) {
DQ = 0; // 将DQ 拉低开始写时间隙
if(bitval==1) DQ =1; // 如果写1，DQ 返回高电平
Delay(5); // 在时间隙内保持电平值，
DQ = 1; // Delay函数每次循环延时16μs，因此delay(5) = 104μs
}
/*******************************************************************/
/* */
/* 写一个字节 */
/* */
/*******************************************************************/
WriteOneChar(unsigned char dat)
{
unsigned char i = 0;
unsigned char temp;
// for (i = 8; i > 0; i--)
// {
for (i=0; i<8; i++) // 写入字节, 每次写入一位
{
// DQ = 0;
// DQ = dat&0x01;
// Delay(5);
// DQ = 1;
temp = dat>>i;
temp &= 0x01;
write_bit(temp);
// dat>>=1;
}
Delay(5);
}
/*******************************************************************/
/* */
/* 读取64位序列码 */
/* */
/*******************************************************************/
Read_RomCord(void)
{
unsigned char j;
Init_DS18B20();
WriteOneChar(0x33); // 读序列码的操作
for (j = 0; j < 8; j++)
{
RomCode[j] = ReadOneChar() ;
}
}
/*******************************************************************/
/* */
/*DS18B20的CRC8校验程序 */
/* */
/*******************************************************************/
uchar CRC8()
{
uchar i,x; uchar crcbuff;
crc=0;
for(x = 0; x <8; x++)
{
crcbuff=RomCode[x];
for(i = 0; i < 8; i++)
{
if(((crc ^ crcbuff)&0x01)==0)
crc >>= 1;
else {
crc ^= 0x18; //CRC=X8+X5+X4+1
crc >>= 1;
crc |= 0x80;
}
crcbuff >>= 1;
}
}
return crc;
}
/*******************************************************************/
/* */
/* 数据转换与显示 */
/* */
/*******************************************************************/
Disp_RomCode()
{
uchar j;
uchar H_num=0x40; //LCD第二行初始位置
for(j=0;j<8;j++)
{
Temp = RomCode[j];
display[0]=((Temp&0xf0)>>4);
if(display[0]>9)
{ display[0]=display[0]+0x37;}
else{display[0]=display[0]+0x30;}
lcd_pos(H_num);
lcd_wdat(display[0]); //高位数显示
H_num++;
display[1]=(Temp&0x0f);
if(display[1]>9)
{display[1]=display[1]+0x37;}
else {display[1]=display[1]+0x30;}
lcd_pos(H_num);
lcd_wdat(display[1]); //低位数显示
H_num++;
}
}
/*******************************************************************/
/* */
/* 蜂鸣器响一声 */
/* */
/*******************************************************************/
void beep()
{
unsigned char y;
for (y=0;y<100;y++)
{
Delay(60);
BEEP=!BEEP; //BEEP取反
}
BEEP=1; //关闭蜂鸣器
Delay(40000);
}
/*******************************************************************/
/* */
/* DS18B20 OK 显示菜单 */
/* */
/*******************************************************************/
void Ok_Menu ()
{
uchar m;
lcd_init(); //初始化LCD
lcd_pos(0); //设置显示位置为第一行的第1个字符
m = 0;
while(cdis1[m] != '\0')
{ //显示字符
lcd_wdat(cdis1[m]);
m++;
}
lcd_pos(0x40); //设置显示位置为第二行第1个字符
m = 0;
while(cdis2[m] != '\0')
{
lcd_wdat(cdis2[m]); //显示字符
m++;
}
}
/*******************************************************************/
/* */
/* DS18B20 ERROR 显示菜单 */
/* */
/*******************************************************************/
void Error_Menu ()
{
uchar m;
lcd_init(); //初始化LCD
lcd_pos(0); //设置显示位置为第一行的第1个字符
m = 0;
while(cdis3[m] != '\0')
{ //显示字符
lcd_wdat(cdis3[m]);
m++;
}
lcd_pos(0x40); //设置显示位置为第二行第1个字符
m = 0;
while(cdis4[m] != '\0')
{
lcd_wdat(cdis4[m]); //显示字符
m++;
}
}
/*******************************************************************/
/* */
/* 主函数 */
/* */
/*******************************************************************/
void main()
{
P0 = 0xff;
P2 = 0xff;
while(1)
{
Ok_Menu ();
Read_RomCord(); //读取64位序列码
CRC8(); //CRC效验
if(crc==0) //CRC效验正确
{
Disp_RomCode(); //显示64位序列码
beep();
}
while(!presence)
{
Init_DS18B20();
delay1(1000);
}
Error_Menu ();
do
{
Init_DS18B20();
beep();
}
while(presence);
}
}
/*******************************************************************/
⑸ 单片机写modbus协议时CRC校验的码表里的值从哪里得来的
这两个表就包含所有的modbus协议CRC校验高低字节的值，上位机的的校验和单片机的校验用法是一样的，一般都是通过判断最后校验字节是否一样，一样的就说明数据正确，否则错误
⑹ 51单片机MODBUS通讯，RTU中的CRC校验
你找一个MODBUS的协议详细资料好好看看，就是一种通讯约定，你按照它规定的格式通讯就可以了
协议发送给询问方。 Modbus协议包括ASCII、RTU、TCP等，并没有规定物理层。此协议定义了控制器能够认识和使用的消息结构，而不管它们是经过何种网络进行通信的。标准的Modicon控制器使用RS232C实现串行的Modbus。Modbus的ASCII、RTU协议规定了消息、数据的结构、命令和就答的方式，数据通讯采用Maser/Slave方式，Master端发出数据请求消息，Slave端接收到正确消息后就可以发送数据到Master端以响应请求；Master端也可以直接发消息修改Slave端的数据，实现双向读写。 Modbus协议需要对数据进行校验，串行协议中除有奇偶校验外，ASCII模式采用LRC校验，RTU模式采用16位CRC校验，但TCP模式没有额外规定校验，因为TCP协议是一个面向连接的可靠协议。另外，Modbus采用主从方式定时收发数据，在实际使用中如果某Slave站点断开后（如故障或关机），Master端可以诊断出来，而当故障修复后，网络又可自动接通。因此，Modbus协议的可靠性较好。 下面我来简单的给大家介绍一下，对于Modbus的ASCII、RTU和TCP协议来说，其中TCP和RTU协议非常类似，我们只要把RTU协议的两个字节的校验码去掉，然后在RTU协议的开始加上5个0和一个6并通过TCP/IP网络协议发送出去即可。所以在这里我仅介绍一下Modbus的ASCII和RTU协议。 下表是ASCII协议和RTU协议进行的比较： 协议 开始标记 结束标记 校验 传输效率 程序处理
ASCII :（冒号） CR,LF LRC 低 直观，简单，易调试
RTU 无 无 CRC 高 不直观，稍复杂
通过比较可以看到，ASCII协议和RTU协议相比拥有开始和结束标记，因此在进行程序处理时能更加方便，而且由于传输的都是可见的ASCII字符，所以进行调试时就更加的直观，另外它的LRC校验也比较容易。但是因为它传输的都是可见的ASCII字符，RTU传输的数据每一个字节ASCII都要用两个字节来传输，比如RTU传输一个十六进制数0xF9,ASCII就需要传输’F’’9’的ASCII码0x39和0x46两个字节，这样它的传输的效率就比较低。所以一般来说，如果所需要传输的数据量较小可以考虑使用ASCII协议，如果所需传输的数据量比较大，最好能使用RTU协议。
下面对两种协议的校验进行一下介绍。
1、LRC校验
LRC域是一个包含一个8位二进制值的字节。LRC值由传输设备来计算并放到消息帧中，接收设备在接收消息的过程中计算LRC，并将它和接收到消息中LRC域中的值比较，如果两值不等，说明有错误。
LRC校验比较简单，它在ASCII协议中使用，检测了消息域中除开始的冒号及结束的回车换行号外的内容。它仅仅是把每一个需要传输的数据按字节叠加后取反加1即可。下面是它的VC代码：
BYTE GetCheckCode(const char * pSendBuf, int nEnd)//获得校验码
{
BYTE byLrc = 0;
char pBuf[4];
int nData = 0;
for(i=1; i<end; i+=2) //i初始为1，避开“开始标记”冒号
{
//每两个需要发送的ASCII码转化为一个十六进制数
pBuf [0] = pSendBuf [i];
pBuf [1] = pSendBuf [i+1];
pBuf [2] = '\0';
sscanf(pBuf,"%x",& nData);
byLrc += nData;
}
byLrc = ~ byLrc;
byLrc ++;
return byLrc;
}
2、CRC校验
CRC域是两个字节，包含一16位的二进制值。它由传输设备计算后加入到消息中。接收设备重新计算收到消息的CRC，并与接收到的CRC域中的值比较，如果两值不同，则有误。
CRC是先调入一值是全“1”的16位寄存器，然后调用一过程将消息中连续的8位字节各当前寄存器中的值进行处理。仅每个字符中的8Bit数据对CRC有效，起始位和停止位以及奇偶校验位均无效。
CRC产生过程中，每个8位字符都单独和寄存器内容相或（OR），结果向最低有效位方向移动，最高有效位以0填充。LSB被提取出来检测，如果LSB为1，寄存器单独和预置的值或一下，如果LSB为0，则不进行。整个过程要重复8次。在最后一位（第8位）完成后，下一个8位字节又单独和寄存器的当前值相或。最终寄存器中的值，是消息中所有的字节都执行之后的CRC值。
CRC添加到消息中时，低字节先加入，然后高字节。下面是它的VC代码：
WORD GetCheckCode(const char * pSendBuf, int nEnd)//获得校验码
{
WORD wCrc = WORD(0xFFFF);
for(int i=0; i<nEnd; i++)
{
wCrc ^= WORD(BYTE(pSendBuf[i]));
for(int j=0; j<8; j++)
{
if(wCrc & 1)
{
wCrc >>= 1;
wCrc ^= 0xA001;
}
else
{
wCrc >>= 1;
}
}
}
return wCrc;
}
对于一条RTU协议的命令可以简单的通过以下的步骤转化为ASCII协议的命令：
1、 把命令的CRC校验去掉，并且计算出LRC校验取代。
2、 把生成的命令串的每一个字节转化成对应的两个字节的ASCII码，比如0x03转化成0x30,0x33（0的ASCII码和3的ASCII码）。
3、 在命令的开头加上起始标记“:”，它的ASCII码为0x3A。
4、 在命令的尾部加上结束标记CR,LF（0xD,0xA），此处的CR,LF表示回车和换行的ASCII码。
所以以下我们仅介绍RTU协议即可，对应的ASCII协议可以使用以上的步骤来生成。
下表是Modbus支持的功能码：
功能码 名称 作用
01 读取线圈状态 取得一组逻辑线圈的当前状态（ON/OFF)
02 读取输入状态 取得一组开关输入的当前状态（ON/OFF)
03 读取保持寄存器 在一个或多个保持寄存器中取得当前的二进制值
04 读取输入寄存器 在一个或多个输入寄存器中取得当前的二进制值
05 强置单线圈 强置一个逻辑线圈的通断状态
06 预置单寄存器 把具体二进值装入一个保持寄存器
07 读取异常状态 取得8个内部线圈的通断状态，这8个线圈的地址由控制器决定
08 回送诊断校验 把诊断校验报文送从机，以对通信处理进行评鉴
09 编程（只用于484） 使主机模拟编程器作用，修改PC从机逻辑
10 控询（只用于484） 可使主机与一台正在执行长程序任务从机通信，探询该从机是否已完成其操作任务，仅在含有功能码9的报文发送后，本功能码才发送
11 读取事件计数 可使主机发出单询问，并随即判定操作是否成功，尤其是该命令或其他应答产生通信错误时
12 读取通信事件记录 可是主机检索每台从机的Modbus事务处理通信事件记录。如果某项事务处理完成，记录会给出有关错误
13 编程（184/384 484 584） 可使主机模拟编程器功能修改PC从机逻辑
14 探询（184/384 484 584） 可使主机与正在执行任务的从机通信，定期控询该从机是否已完成其程序操作，仅在含有功能13的报文发送后，本功能码才得发送
15 强置多线圈 强置一串连续逻辑线圈的通断
16 预置多寄存器 把具体的二进制值装入一串连续的保持寄存器
17 报告从机标识 可使主机判断编址从机的类型及该从机运行指示灯的状态
18 （884和MICRO 84） 可使主机模拟编程功能，修改PC状态逻辑
19 重置通信链路 发生非可修改错误后，是从机复位于已知状态，可重置顺序字节
20 读取通用参数（584L） 显示扩展存储器文件中的数据信息
21 写入通用参数（584L） 把通用参数写入扩展存储文件，或修改之
22～64 保留作扩展功能备用
65～72 保留以备用户功能所用 留作用户功能的扩展编码
73～119 非法功能
120～127 保留 留作内部作用
128～255 保留 用于异常应答
在这些功能码中较长使用的是1、2、3、4、5、6号功能码，使用它们即可实现对下位机的数字量和模拟量的读写操作。
1、读可读写数字量寄存器（线圈状态）：
计算机发送命令：[设备地址] [命令号01] [起始寄存器地址高8位] [低8位] [读取的寄存器数高8位] [低8位] [CRC校验的低8位] [CRC校验的高8位]
例：[11][01][00][13][00][25][CRC低][CRC高]
意义如下：
<1>设备地址：在一个485总线上可以挂接多个设备，此处的设备地址表示想和哪一个设备通讯。例子中为想和17号(十进制的17是十六进制的11)通讯。
<2>命令号01：读取数字量的命令号固定为01。
<3>起始地址高8位、低8位：表示想读取的开关量的起始地址(起始地址为0)。比如例子中的起始地址为19。
<4>寄存器数高8位、低8位：表示从起始地址开始读多少个开关量。例子中为37个开关量。
<5>CRC校验：是从开头一直校验到此之前。在此协议的最后再作介绍。此处需要注意，CRC校验在命令中的高低字节的顺序和其他的相反。
设备响应：[设备地址] [命令号01] [返回的字节个数][数据1][数据2]...[数据n][CRC校验的低8位] [CRC校验的高8位]
例：[11][01][05][CD][6B][B2][0E][1B][CRC低][CRC高]
意义如下：
<1>设备地址和命令号和上面的相同。
<2>返回的字节个数：表示数据的字节个数，也就是数据1，2...n中的n的值。
<3>数据1...n：由于每一个数据是一个8位的数，所以每一个数据表示8个开关量的值，每一位为0表示对应的开关断开，为1表示闭合。比如例子中，表示20号(索引号为19)开关闭合，21号断开，22闭合，23闭合，24断开，25断开，26闭合，27闭合...如果询问的开关量不是8的整倍数，那么最后一个字节的高位部分无意义，置为0。
<4>CRC校验同上。
2、读只可读数字量寄存器（输入状态）：
和读取线圈状态类似，只是第二个字节的命令号不再是1而是2。
3、写数字量（线圈状态）：
计算机发送命令：[设备地址] [命令号05] [需下置的寄存器地址高8位] [低8位] [下置的数据高8位] [低8位] [CRC校验的低8位] [CRC校验的高8位]
例：[11][05][00][AC][FF][00][CRC低][CRC高]
意义如下：
<1>设备地址和上面的相同。
<2>命令号:写数字量的命令号固定为05。
<3>需下置的寄存器地址高8位，低8位：表明了需要下置的开关的地址。
<4>下置的数据高8位，低8位：表明需要下置的开关量的状态。例子中为把该开关闭合。注意，此处只可以是[FF][00]表示闭合[00][00]表示断开，其他数值非法。
<5>注意此命令一条只能下置一个开关量的状态。
设备响应：如果成功把计算机发送的命令原样返回，否则不响应。
4、读可读写模拟量寄存器（保持寄存器）：
计算机发送命令：[设备地址] [命令号03] [起始寄存器地址高8位] [低8位] [读取的寄存器数高8位] [低8位] [CRC校验的低8位] [CRC校验的高8位]
例：[11][03][00][6B][00][03][CRC低][CRC高]
意义如下：
<1>设备地址和上面的相同。
<2>命令号:读模拟量的命令号固定为03。
<3>起始地址高8位、低8位：表示想读取的模拟量的起始地址(起始地址为0)。比如例子中的起始地址为107。
<4>寄存器数高8位、低8位：表示从起始地址开始读多少个模拟量。例子中为3个模拟量。注意，在返回的信息中一个模拟量需要返回两个字节。
设备响应：[设备地址] [命令号03] [返回的字节个数][数据1][数据2]...[数据n][CRC校验的低8位] [CRC校验的高8位]
例：[11][03][06][02][2B][00][00][00][64][CRC低][CRC高]
意义如下：
<1>设备地址和命令号和上面的相同。
<2>返回的字节个数：表示数据的字节个数，也就是数据1，2...n中的n的值。例子中返回了3个模拟量的数据，因为一个模拟量需要2个字节所以共6个字节。
<3>数据1...n：其中[数据1][数据2]分别是第1个模拟量的高8位和低8位，[数据3][数据4]是第2个模拟量的高8位和低8位，以此类推。例子中返回的值分别是555，0，100。
<4>CRC校验同上。
5、读只可读模拟量寄存器（输入寄存器）：
和读取保存寄存器类似，只是第二个字节的命令号不再是2而是4。
6、写单个模拟量寄存器（保持寄存器）：
计算机发送命令：[设备地址] [命令号06] [需下置的寄存器地址高8位] [低8位] [下置的数据高8位] [低8位] [CRC校验的低8位] [CRC校验的高8位]
例：[11][06][00][01][00][03][CRC低][CRC高]
意义如下：
<1>设备地址和上面的相同。
<2>命令号:写模拟量的命令号固定为06。
<3>需下置的寄存器地址高8位，低8位：表明了需要下置的模拟量寄存器的地址。
<4>下置的数据高8位，低8位：表明需要下置的模拟量数据。比如例子中就把1号寄存器的值设为3。
<5>注意此命令一条只能下置一个模拟量的状态。
设备响应：如果成功把计算机发送的命令原样返回，否则不响应。
⑺ 谁有51单片机串口通信crc16校验C程序
unsigned int mc_crc16(unsigned char *daBuf,unsigned char len)//Crc16校验
{
bit BitFg;
unsigned char idata i,j;
unsigned char BiTemp=0;
unsigned int idata CRCBuf = 0xffff;
for(j=0;j<len;j++)
{
CRCBuf ^= daBuf[j];
for(i=0;i<8;i++)
{
BitFg = CRCBuf&1;
CRCBuf >>= 1;
if(BitFg==1)
CRCBuf ^= 0xa001;
CRCBuf = CRCBuf&0xffff;
}
}
return(CRCBuf);
}
⑻ 用单片机汇编语言或C51语言或实现CRC校验码
Uint16 Crc16(unsigned char *puchMsg, int usDataLen)
{
unsigned int uchCRCHi = 0xFF ; /* 高CRC字节初始化 */
unsigned int uchCRCLo = 0xFF ; /* 低CRC 字节初始化 */
unsigned int temp16;
Uint32 uIndex ; /* CRC循环中的索引 */
while (usDataLen--) /* 传输消息缓冲区 */
{
temp16=*puchMsg++;
uIndex = uchCRCHi ^ temp16 ; /* 计算CRC */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
uchCRCLo = auchCRCLo[uIndex] ;
}
return (uchCRCHi << 8 | uchCRCLo) ;
}
⑼ 设计基于89c51单片机的CRC循环冗余校验码的编码及解码器
有一个成功的解码器，没有编码器，子程序如下：
uint CRC16(uchar *puchMsg, uchar usDataLen)
{
uchar uchCRCHi = 0xFF ; // 高CRC字节初始化
uchar uchCRCLo = 0xFF ; // 低CRC字节初始化
uchar uIndex; //CRC循环中的索引
while(usDataLen--) //传输消息缓冲区
{
uIndex = uchCRCHi ^ *puchMsg++ ;// 计算CRC */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
uchCRCLo = auchCRCLo[uIndex] ;
}
return (uchCRCLo << 8 | uchCRCHi) ;
}