Subversion Repositories common

//////////////////////////////////////////////////////////////////////
////                                                              ////
//// grey_to_binary #(N), binary_to_grey #(N)                     ////
////                                                              ////
//// This file is part of the general opencores effort.           ////
//// <http://www.opencores.org/cores/misc/>                       ////
////                                                              ////
//// Module Description:                                          ////
////    Example of how to convert Grey Code to Binary.            ////
////    Example of how to convert Binary to Grey Code.            ////
////                                                              ////
//// CRITICAL USAGE NOTE:                                         ////
////    These functions produce combinational outputs which       ////
////      have glitches.  To use these safely, the outputs        ////
////      must be latched using the same clock before and         ////
////      after the combinational function.                       ////
////                                                              ////
////    There are other sequences of numbers which share the      ////
////      property of Grey Code that only 1 bit transitions per   ////
////      value change.                                           ////
////    The sequence 0x00, 0x1, 0x3, 0x2, 0x6, 0x4 is one such    ////
////      sequence.                                               ////
////    It should be possible to make a library which counts      ////
////      in sequences less than 2**n long, yet which still       ////
////      change only 1 bot per increment.                        ////
////                                                              ////
//// To Do:                                                       ////
//// Might make this handle more than 16 bits.                    ////
////                                                              ////
//// Author(s):                                                   ////
//// - Anonymous                                                  ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2000 Anonymous and OPENCORES.ORG               ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// This source file is free software; you can redistribute it   ////
//// and/or modify it under the terms of the GNU Lesser General   ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source is distributed in the hope that it will be       ////
//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////
//// PURPOSE. See the GNU Lesser General Public License for more  ////
//// details.                                                     ////
////                                                              ////
//// You should have received a copy of the GNU Lesser General    ////
//// Public License along with this source; if not, download it   ////
//// from <http://www.opencores.org/lgpl.shtml>                   ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
//
// $Id: grey_to_binary.v,v 1.5 2001-10-22 12:29:08 bbeaver Exp $
//
// CVS Revision History
//
// $Log: not supported by cvs2svn $
// Revision 1.3  2001/09/03 12:12:44  Blue Beaver
// no message
//
// Revision 1.2  2001/09/03 12:09:24  Blue Beaver
// no message
//
//
 
`timescale 1ns/1ps
 
// Convert 2-bit up to 16-bit binary value into same sized grey-code value
 
module bin_to_grey_code (
  grey_code_out,
  binary_in
);
  parameter NUM_BITS = 1;  // instantiate as "bin_to_grey_code #(width) instance ()"
 
  output [NUM_BITS - 1 : 0] grey_code_out;
  input  [NUM_BITS - 1 : 0] binary_in;
 
// Consider the sequences
//   Binary  Grey Code
//     00       00
//     01       01
//     10       11
//     11       10
// It seems that G[1] = B[1], and G[0] = B[1] ^ B[0];
// Now consider the sequences
//   Binary  Grey Code
//     000      000
//     001      001
//     010      011
//     011      010
//     100      110
//     101      111
//     110      101
//     111      100
// It seems that G[2] = B[2], and
//               G[1] = B[2] ^ B[1], and
//               G[0] = B[1] ^ B[0];
//
// But how to write that using a parameter?  Well, instead of
//   figuring it out, how about just making something which works
//   for a range of widths, like 2 to 16?
 
  wire   [15:0] widened_input = {binary_in[NUM_BITS - 1 : 0], {16 - NUM_BITS{1'b0}}};
 
  wire   [15:0] widened_output = {
                      widened_input[15],
                      widened_input[15] ^ widened_input[14],
                      widened_input[14] ^ widened_input[13],
                      widened_input[13] ^ widened_input[12],
                      widened_input[12] ^ widened_input[11],
                      widened_input[11] ^ widened_input[10],
                      widened_input[10] ^ widened_input[9],
                      widened_input[9]  ^ widened_input[8],
                      widened_input[8]  ^ widened_input[7],
                      widened_input[7]  ^ widened_input[6],
                      widened_input[6]  ^ widened_input[5],
                      widened_input[5]  ^ widened_input[4],
                      widened_input[4]  ^ widened_input[3],
                      widened_input[3]  ^ widened_input[2],
                      widened_input[2]  ^ widened_input[1],
                      widened_input[1]  ^ widened_input[0]
                  };
 
  assign  grey_code_out[NUM_BITS - 1 : 0] = widened_output[15 : 16 - NUM_BITS];
 
// synopsys translate_off
  initial
  begin
    if (NUM_BITS < 2)
    begin
      $display ("*** Exiting because %m bin_to_grey_code Number of bits %d < 2",
                   NUM_BITS);
      $finish;
    end
    if (NUM_BITS > 16)
    begin
      $display ("*** Exiting because %m bin_to_grey_code Number of bits %d > 16",
                   NUM_BITS);
      $finish;
    end
  end
// synopsys translate_on
endmodule
 
// Convert 2-bit up to 16-bit binary value into same sized grey-code value
 
module grey_code_to_bin (
  binary_out,
  grey_code_in
);
  parameter NUM_BITS = 1;  // instantiate as "grey_code_to_bin #(width) instance ()"
 
  output [NUM_BITS - 1 : 0] binary_out;
  input  [NUM_BITS - 1 : 0] grey_code_in;
 
// Consider the sequences
//   Grey Code   Binary
//       00        00
//       01        01
//       11        10
//       10        11
// It seems that B[1] = G[1], and B[0] = G[1] ^ G[0];
// Now consider the sequences
//   Grey Code   Binary
//      000       000
//      001       001
//      011       010
//      010       011
//      110       100
//      111       101
//      101       110
//      100       111
// It seems that B[2] = G[2], and
//               B[1] = G[2] ^ G[1], and
//               B[0] = G[2] ^ G[1] ^ G[0];
//
// But how to write that using a parameter?  Well, instead of
//   figuring it out, how about just making something which works
//   for a range of widths, like 2 to 16?
 
  wire   [15:0] widened_input = {grey_code_in[NUM_BITS - 1 : 0], {16 - NUM_BITS{1'b0}}};
  wire    xor_15_12 = widened_input[15] ^ widened_input[14]
                    ^ widened_input[13] ^ widened_input[12];
  wire    xor_11_10 = widened_input[11] ^ widened_input[10];
  wire    xor_11_8  = widened_input[11] ^ widened_input[10]
                    ^ widened_input[9]  ^ widened_input[8];
  wire    xor_7_6   = widened_input[7]  ^ widened_input[6];
  wire    xor_7_4   = widened_input[7]  ^ widened_input[6]
                    ^ widened_input[5]  ^ widened_input[4];
  wire    xor_3_2   = widened_input[3]  ^ widened_input[2];
  wire    xor_1_0   = widened_input[1]  ^ widened_input[0];
 
  wire   [15:0] widened_output = {
                      widened_input[15],
                      widened_input[15] ^ widened_input[14],
                      widened_input[15] ^ widened_input[14] ^ widened_input[13],
                      xor_15_12,
                      xor_15_12 ^ widened_input[11],
                      xor_15_12 ^ xor_11_10,
                      xor_15_12 ^ xor_11_10 ^ widened_input[9],
                      xor_15_12 ^ xor_11_8,
                      xor_15_12 ^ xor_11_8 ^ widened_input[7],
                      xor_15_12 ^ xor_11_8 ^ xor_7_6,
                      xor_15_12 ^ xor_11_8 ^ xor_7_6 ^ widened_input[5],
                      xor_15_12 ^ xor_11_8 ^ xor_7_4,
                      xor_15_12 ^ xor_11_8 ^ xor_7_4 ^ widened_input[3],
                      xor_15_12 ^ xor_11_8 ^ xor_7_4 ^ xor_3_2,
                      xor_15_12 ^ xor_11_8 ^ xor_7_4 ^ xor_3_2 ^ widened_input[1],
                      xor_15_12 ^ xor_11_8 ^ xor_7_4 ^ xor_3_2 ^ xor_1_0
                  };
 
  assign  binary_out[NUM_BITS - 1 : 0] = widened_output[15 : 16 - NUM_BITS];
 
// synopsys translate_off
  initial
  begin
    if (NUM_BITS < 2)
    begin
      $display ("*** Exiting because %m grey_code_to_bin Number of bits %d < 2",
                   NUM_BITS);
      $finish;
    end
    if (NUM_BITS > 16)
    begin
      $display ("*** Exiting because %m grey_code_to_bin Number of bits %d > 16",
                   NUM_BITS);
      $finish;
    end
  end
// synopsys translate_on
endmodule
 
 `define TEST_GREY_CODE
`ifdef TEST_GREY_CODE
module test_grey_code;
  reg    [7:0] test_val;
  wire   [1:0] grey_2;
  wire   [2:0] grey_3;
  wire   [3:0] grey_4;
 
  wire   [1:0] bin_2;
  wire   [2:0] bin_3;
  wire   [3:0] bin_4;
 
  initial
  begin
    for (test_val = 8'h00; test_val < 8'h04; test_val = test_val + 8'h01)
    begin
      # 0; $display ("test val, result %x %x %x", test_val[1:0], grey_2[1:0], bin_2[1:0]);
      if (test_val[1:0] !== bin_2[1:0])
        $display ("*** Encode, Decode failed %x %x", test_val[1:0], bin_2[1:0]);
    end
    $display (" ");
    for (test_val = 8'h00; test_val < 8'h08; test_val = test_val + 8'h01)
    begin
      # 0; $display ("test val, result %x %x %x", test_val[2:0], grey_3[2:0], bin_3[2:0]);
      if (test_val[2:0] !== bin_3[2:0])
        $display ("*** Encode, Decode failed %x %x", test_val[2:0], bin_3[2:0]);
    end
    $display (" ");
    for (test_val = 8'h00; test_val < 8'h10; test_val = test_val + 8'h01)
    begin
      # 0; $display ("test val, result %x %x %x", test_val[3:0], grey_4[3:0], bin_4[3:0]);
      if (test_val[3:0] !== bin_4[3:0])
        $display ("*** Encode, Decode failed %x %x", test_val[3:0], bin_4[3:0]);
    end
 
  end
 
bin_to_grey_code #(2) bin_to_grey_code_2 (
  .grey_code_out              (grey_2[1:0]),
  .binary_in                  (test_val[1:0])
);
bin_to_grey_code #(3) bin_to_grey_code_3 (
  .grey_code_out              (grey_3[2:0]),
  .binary_in                  (test_val[2:0])
);
bin_to_grey_code #(4) bin_to_grey_code_4 (
  .grey_code_out              (grey_4[3:0]),
  .binary_in                  (test_val[3:0])
);
 
grey_code_to_bin #(2) grey_code_to_bin_2 (
  .binary_out                 (bin_2[1:0]),
  .grey_code_in               (grey_2[1:0])
);
grey_code_to_bin #(3) grey_code_to_bin_3 (
  .binary_out                 (bin_3[2:0]),
  .grey_code_in               (grey_3[2:0])
);
grey_code_to_bin #(4) grey_code_to_bin_4 (
  .binary_out                 (bin_4[3:0]),
  .grey_code_in               (grey_4[3:0])
);
 
endmodule
`endif  // TEST_GREY_CODE