什么是格雷码？

格雷码，又叫循环二进制码或反射二进制码，格雷码是我们在工程中常会遇到的一种编码方式，它的基本的特点就是任意两个相邻的代码只有一位二进制数不同。



二进制格雷码与自然二进制码的互换

1、二进制码转换成二进制格雷码 

法则是保留二进制码的最高位作为格雷码的最高位；次高位格雷码为二进制码的高位与次高位相异或，其余各位类似。 



static unsigned int DecimaltoGray(unsigned int x){
     return x^(x>>1);
}
 //以上代码实现了unsigned int型数据到格雷码的转换，最高可转换32位自然二进制码，超出32位将溢出。   

2、二进制格雷码转换成二进制码 

法则是保留格雷码的最高位作为自然二进制码的最高位；次高位自然二进制码为高位自然二进制码与次高位格雷码相异或，其余各位类似。 



static unsigned int GraytoDecimal(unsigned int x) {
    unsigned int y = x;
    while(x>>=1)
    y ^= x;
    return y;
}   


借鉴：https://blog.csdn.net/jingfengvae/article/details/51691124

(1)Java将字符串转成二进制码

public void toBinary(){

String str = “王雪”;

char[] strChar=str.toCharArray();

String result="";

for(int i=0;i<strChar.length;i++){

result +=Integer.toBinaryString(strChar[i])+ " ";

}

System.out.println(result);

}
(2)Java将二进制码转成字符串
将二进制字符串转换成int数组

public int[] BinstrToIntArray(String binStr) {

char[] temp=binStr.toCharArray();

int[] result=new int[temp.length];

for(int i=0;i<temp.length;i++) {

result[i]=temp[i]-48;

}

return result;

}
将二进制转换成字符

public char BinstrToChar(String binStr){

int[] temp=BinstrToIntArray(binStr);

int sum=0;

for(int i=0; i<temp.length;i++){

sum +=temp[temp.length-1-i]<<i;

}

return (char)sum;

}

public void BinstrToStr(){

String binStr = "111001110001011 1001011011101010 “;

String[] tempStr=binStr.split(” ");

char[] tempChar=new char[tempStr.length];

for(int i=0;i<tempStr.length;i++) {

tempChar[i]=BinstrToChar(tempStr[i]);

}

System.out.println(String.valueOf(tempChar));

}

二进制码和格雷码之间的转换
一、二进制码与格雷码转换原理

（1）二进制码转换格雷码
二进制码     Bi       Bi-1     Bi-2    ...      B1     B0
             ^        ^        ^               ^      ^
B >>1        0        Bi      Bi-1    ...      B2     B1

格雷码       Gi       Gi-1     Gi-2    ...      G1     G0


（2）格雷码转换二进制码
  Bi  = Gi ;                                        
  Bi-1 = Bi ^ Gi-1 = Gi ^ Gi-1 ;                        
  Bi-2 = Bi-1 ^ Gi-2 = Gi ^ Gi-1 ^ Gi-2 ;	
  :
  :	  
  :
  B3   = B4 ^ G3 = Gi ^ Gi-1 ^ Gi-2 ... ^ G3;
  B2   = B3 ^ G2 = Gi ^ Gi-1 ^ Gi-2 ... ^ G3 ^ G2;	  
  B1   = B2 ^ G1 = Gi ^ Gi-1 ^ Gi-2 ... ^ G3 ^ G2 ^ G1;	     
  B0   = B2 ^ G1 = Gi ^ Gi-1 ^ Gi-2 ... ^ G3 ^ G2 ^ G1 ^ G0;



（3）二进制码与格雷码转换的Verilog实现

数值回环，输入二进制码数值，内部转换格雷码，再次转换为二进制码，验证代码的功能
module class_7_GB_BG#(
   parameter      WIDTH    =    4
   )(
   input             [WIDTH-1:00]           i_bin_data  ,

   output            [WIDTH-1:00]           o_grey_data ,   
   output    reg     [WIDTH-1:00]           o_bin_data
);	
/********二进制码转换格雷码***********************/
	assign  o_grey_data = (i_bin_data >> 1) ^ i_bin_data;
/********二进制码转换格雷码***********************/
/********格雷码转换二进制码***********************/
    integer i;	
	always@(o_grey_data)
	begin
	   for(i=0;i<WIDTH;i=i+1)
	       begin
		      o_bin_data[i] <= ^ (o_grey_data >> i);
		   end
	end	
/********格雷码转换二进制码***********************/
endmodule

（4）仿真testbench文件
module tb_class7#(  
   parameter      WIDTH    =    4 
);
   reg             [WIDTH-1:00]           i_bin_data; 
   wire            [WIDTH-1:00]           o_grey_data;   
   wire            [WIDTH-1:00]           o_bin_data;
class_7_GB_BG#(
   .WIDTH(WIDTH)
   )u_class_7_GB_BG(
   .i_bin_data  (i_bin_data) , 
   .o_grey_data (o_grey_data),   
   .o_bin_data  (o_bin_data)
);
initial  begin
i_bin_data = 0;
#100;
i_bin_data = 1;
#100;
i_bin_data = 2;
#100;
i_bin_data = 3;
#100;
i_bin_data = 4;
#100;
i_bin_data = 5;
#100;
i_bin_data = 6;
#100;
i_bin_data = 7;
#100;
i_bin_data = 8;
#100;
i_bin_data = 9;
#100;
i_bin_data = 10;
#100;
i_bin_data = 11;
#100;
i_bin_data = 12;
#100;
i_bin_data = 13;
#100;
i_bin_data = 14;
#100;
i_bin_data = 15;
#100;
end
endmodule

（5）仿真结果

仿真输出预计值对照表



仿真测试值

自然二进制码与格雷码相互转换
一、格雷码简介
格雷码是由弗兰克·格雷于1953年发明，其主要特点是相邻编码值中间只有一个比特发生改变，又被称为循环码。
格雷码是一种无权码，采用绝对编码方式，典型格雷码是一种具有反射特性和循环特性的单步自补码，它在任意两个相邻的数之间转换时，只有一个数位发生变化。它大大地减少了由一个状态到下一个状态时逻辑的混淆。
二、自然二进制码转换为格雷码
自然二进制码转换成二进制格雷码，其法则是保留自然二进制码的最高位作为格雷码的最高位，而次高位格雷码为二进制码的高位与次高位相异或，格雷码其余各位依次求之。
原理: 
若二进制码表示为: B[N-1]B[N-2]...B[2]B[1]B[0]，
则二进制格雷码表示为: G[N-1]G[N-2]...G[2]G[1]G[0]。
其中最高位保留: G[N-1] = B[N-1]，
其他各位: G[i] = B[i+1] xor B[i]. (i = 0, 1, 2, ..., n-2)。

图示如下：


代码如下：
module b_to_g(binary,gray);
	
	parameter PTR = 8;   //设置位数
	
	input  [PTR-1:0] binary;
	output [PTR-1:0] gray;
	
	reg [PTR-1:0] gray;
	integer i;
	
	always @(*) begin
		for (i=0; i<PTR-1; i=i+1)
			begin 
				gray[i] = binary[i] ^ binary[i+1]; 
			end
		gray[PTR-1] = binary[PTR-1];
	end
	
endmodule

测试代码如下:
//b_to_g_tb

`timescale 1 ns/ 1ns

module b_to_g_tb();
  
    parameter PTR = 8;
	reg  [PTR-1:0] binary;
	wire [PTR-1:0] gray;
	
	integer i;
	
	b_to_g my_b_to_g(
		.binary(binary),
		.gray(gray));
		
	initial
	begin
		binary = 0;
		#2 for(i=0;i<20;i=i+1)
			begin
				#2 binary = $random;
			end
	end
	
endmodule

仿真波形如下（清晰显示请点开放大）：

三、格雷码转换为自然二进制码
二进制格雷码转换成自然二进制码，其法则是保留格雷码的最高位作为自然二进制码的最高位，而次高位自然二进制码为高位自然二进制码与次高位格雷码相异或，而自然二进制码的其余各位依次求之。
原理: 
若二进制格雷码表示为: G[N-1]G[N-2]...G[2]G[1]G[0]，
则二进制码表示为: B[N-1]B[N-2]...B[2]B[1]B[0]。
其中最高位保留: B[N-1] = G[N-1];
其他各位: B[i-1] = G[i-1] xor B[i]. (i = 1, 2, ..., n-1)。

图示如下：


代码如下：
module g_to_b (
  binary, gray);
   
  parameter PTR = 8;
  input  [PTR-1:0] gray;
  output [PTR-1:0] binary;
  
  integer i;
  reg [PTR-1:0] binary;
  
  always @(*) begin
 	 //这里我用for (i=0; i<PTR-1; i=i+1)的话，仿真结果不对。
 	 //不大清楚，有明白的同学请指出。
    for (i=PTR-2; i>=0; i=i-1)  
      begin
        binary[i] = binary[i+1] ^ gray[i];
      end
      binary[PTR-1] = gray[PTR-1];
  end
  
endmodule
  

测试代码如下:
//g_to_b_tb

`timescale 1 ns/1 ns

module g_to_b_tb();
  
  parameter PTR = 8;
  integer i;
  
  reg   [PTR-1:0] gray;
  wire  [PTR-1:0] binary;
  
  g_to_b my_g_to_b(
 	 .gray(gray),
 	 .binary(binary)
	  );
  
  initial
  begin
    gray = 0;
    #2 for (i=0; i<30; i=i+1)
        begin
          #2 gray = $random;
        end
  end
  
endmodule

仿真波形如下（清晰显示请点开放大）：

四、参考资料
链接: 格雷码（Gray）和二进制（Binary）之间的相互转换.