CRC校验

一、概念

CRC即循环冗余校验码(Cyclic Redundancy Check)：是数据通信领域中最常用的一种差错校验码，其特征是信息

字段和检验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将

结构附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性。

 

二、计算

我们假设条件如下：

  （1）传送的原始消息msg：1,1,0,1,0,0,1,1

  （2）给定的生成多项式为gEx：x^4+x+1 即名称为CRC-4

从条件我们可以得到：

根据生成多项式得出生成多项式字码gExCode：1,0,0,1,1

根据生成多项式字码得到校验码码长r=5-1=4

根据原始消息我们得到原始消息表达式为：mEx=x^7+x^6+x^4+x^1+1

因此我们将原始消息向左移动4位：mEx*x^4=x^11+x^10+x^8+x^5+x^4

11 10 9 8 7 6 5 4 3 2 1 0 （多项式的次数）

1 1 0 1 0 0 1 1 0 0 0 0 （得到多项式相关的字码）

从上面的转换（当然也可以从原始消息直接看出）原始消息左移四位后的字码为：110100110000

然后我们用110100110000对生成多项式字码进行模2除法运算：

  1 1 0 1 0 0 1 1 0 0 0 0

^

  1 0 0 1 1

      ———————————

       0 1 0 0 1 0 1 1 0 0 0 0

       ^

          1 0 0 1 1

        ————————————

          0 0 0 0 1 1 1 0 0 0 0

                  ^

                     1 0 0 1 1

                   ————————

                     0 1 1 1 1 0 0

                     ^ 

                        1 0 0 1 1

                     ————————

                        0 1 1 0 1 0

                        ^ 1 0 0 1 1

                        ———————

                           0 1 0 0 1

所以校验码就是余数：1001

将余数放到原始消息的末尾就构成了最终发送的消息：

1 1 0 1 0 0 1 1 1 0 0 1

 

接收方拿到这个消息后，将其与生成多项式码进行模2除法，如果余数为0，则发送的消息没有差错；反之，则发送的消息存在差错。

 

三、错误检测 

当接收方收到数据后，用收到的数据对实现约定给定码进行模2除法，若余数为0，则认为数据传输无差错；若

余数不为0，则认为数据传输出现了错误，由于不知道错误发生在什么地方，因此不能进行自动纠正，一般的做法

就是丢弃接收到的数据。

 

四、Java代码来模拟这个算法

public class CRCcheck {
   public static void main(String[]args) {
       String code="CRC-4";
       if(!generatePolyMap.containsKey(code)) {
           System.out.println("不存在此编码");
           return;
       }
       
       int[]gEx=generatePolyMap.get(code);
       int[] msg=send(new int[]{1,1,0,1,0,0,1,1},gEx);
       accept(msg,gEx,gEx.length-1);
   }

   //一些固定的事先约定好的生成多项式
   final static Map<String,int[]> generatePolyMap=new HashMap<String,int[]> ();
   static {
       generatePolyMap.put("CRC-4", new int[]{1,0,0,1,1});
       generatePolyMap.put("CRC-8", new int[]{1,0,0,1,1,0,0,0,1});
       generatePolyMap.put("CRC-12",new int[]{1,1,0,0,0,0,0,0,0,1,0,1,0,1});
   }
   
   
   public static int[] send(int[] msg,int[] gEx) {
       //校验码位数
       int r=gEx.length-1;
       
       //信息字码长度
       int k=msg.length;
       
       //最终发送信息长度,并生成最终放信息的空间
       int l=r+k;
       int[] m=new int[l];
       
       //初始化新的消息空间
       for(int i=0;i<l;i++) {
           m[i]=0;
       }
       
       //将原始消息左移r位
       System.out.print("原始消息：");
       for(int i=0;i<k;i++) {
           System.out.print(msg[i]+"\t");
           m[i]=msg[i];
       }
       
       System.out.println();
       
       int[] remainder=new int[r];
       int[] tmp=new int[l];
       for(int i=0;i<l;i++) {
           tmp[i]=m[i];
       }
       
       int[] result=modDivNum(tmp,gEx,r,remainder,true);
       
       System.out.print("检验码：  ");
       for(int i=0;i<result.length;i++) {
           System.out.print(result[i]+"\t");
       }
       System.out.println();
       
       
       int t=1;
       for(int i=result.length-1;i>=0;i--) {
           m[l-t]=result[i];
           t++;
       }
       
       System.out.print("发送消息：");
       for(int i=0;i<m.length;i++) {
           System.out.print(m[i]+"\t");
       }
       System.out.println();
       return m;
   }
   
   
   public static void accept(int[]msg,int[]gEx,int r) {
       boolean flag=validate(msg,gEx,r);
       if(flag) {
           System.out.println("接收的消息完好无损");
           return;
       }
       System.out.println("接收的消息有损伤");
   }
   
   private static boolean validate(int[] sendMsg,int[] gEx,int r) {
       if(sendMsg.length<r) {
           for(int i=0;i<sendMsg.length;i++) {
               if(sendMsg[i]==1) {
                   return false;
               }
           }
           
           return true;
       }
       for(int i=0;i<gEx.length;i++) {
           sendMsg[i]=gEx[i]^sendMsg[i];
       }
       
       boolean flag=true;
       int firstSerizeZeroCount=0;
       int count=0;
       for(int i=0;i<sendMsg.length;i++) {
           if(flag&&sendMsg[i]==0) {
               firstSerizeZeroCount++;
               continue;
           }
           if(sendMsg[i]==1) {
               flag=false;
           }
           count++;
       }
       
       int[] tmpMsg=new int[count];
       int k=0;
       for(int i=firstSerizeZeroCount;i<sendMsg.length;i++) {
           tmpMsg[k++]=sendMsg[i];
       }
       
       sendMsg=tmpMsg;
       return validate(sendMsg,gEx,r) ;
   }
   
   private static int[] modDivNum(int[]m,int[]gEx,int r,int[] result,boolean f) {
       if(!f && result.length<=r) {
           return result;
       }
       
       for(int i=0;i<gEx.length;i++) {
           m[i]=gEx[i]^m[i];
       }
       
       
       boolean flag=true;
       int count=0;
       int n=0;
       for(int i=0;i<m.length;i++) {
           if(m[i]==1) {
               flag=false;
           }
           
           if(flag&&m[i]==0) {//前面的都是0
               n++;  //记录前面0的个数
               continue;
           }
           
           count++;
       }
       
       result=new int[count];
       
       int j=0;
       for(int i=n;i<m.length;i++) {
           result[j++]=m[i];
       }
       
       m=result;
       
       return modDivNum(m,gEx,r,result,false);
   }
    
}