// ================================================================================
// (c) 2004 Altera Corporation. All rights reserved.
// Altera products are protected under numerous U.S. and foreign patents, maskwork
// rights, copyrights and other intellectual property laws.
// 
// This reference design file, and your use thereof, is subject to and governed
// by the terms and conditions of the applicable Altera Reference Design License
// Agreement (either as signed by you, agreed by you upon download or as a
// "click-through" agreement upon installation andor found at www.altera.com).
// By using this reference design file, you indicate your acceptance of such terms
// and conditions between you and Altera Corporation.  In the event that you do
// not agree with such terms and conditions, you may not use the reference design
// file and please promptly destroy any copies you have made.
// 
// This reference design file is being provided on an "as-is" basis and as an
// accommodation and therefore all warranties, representations or guarantees of
// any kind (whether express, implied or statutory) including, without limitation,
// warranties of merchantability, non-infringement, or fitness for a particular
// purpose, are specifically disclaimed.  By making this reference design file
// available, Altera expressly does not recommend, suggest or require that this
// reference design file be used in combination with any other product not
// provided by Altera.
// ================================================================================
//----------------------------------------------------------------------------------------------------------------------
// parameterizable gray code counter with synchronous enable.
//-----------------------------------------------------------------------------
`timescale 1ns/1ns
       
module gray_count
  (
   clk,
   reset_n,
   en,
   
   gray,
   binary,
   next_gray,
   next_binary
   );
  
  parameter WIDTH = 2;

  input clk;
  input reset_n;
  input en;

  output [WIDTH-1:0] gray;
  output [WIDTH-1:0] binary;
  output [WIDTH-1:0] next_gray;
  output [WIDTH-1:0] next_binary;

  reg [WIDTH-1:0]    binary;
  reg [WIDTH-1:0]    gray;

  // next_binary and next_gray anticipate the codes. These are combinatorial
  // function of the binary count and so may have multiple bits toggling.
//  wire [WIDTH-1:0]   next_binary = binary + {{WIDTH-1{1'b0}}, 1'b1};
  reg [WIDTH-1:0]    next_binary;

  // Use negedge for next_binary to see if it helps in use of carry chains
  always @(negedge clk or negedge reset_n)
    if (~reset_n)
      next_binary <= {WIDTH{1'b0}};
    else
      next_binary <= binary + {{WIDTH-1{1'b0}}, 1'b1};
  
  wire [WIDTH-1:0]   next_gray = next_binary ^ (next_binary>>1);

  // gray output is registered from next_grey so as to guarantee only one bit will
  // change. this allows it to be passed between clock domains and still be sampled
  // as either the old or new value
  always @(posedge clk or negedge reset_n)
  begin
    if (~reset_n)
    begin
      gray <= {WIDTH{1'b0}};
      binary <= {WIDTH{1'b0}};
    end
    else if (en)
    begin
      gray <= next_gray;
      binary <= next_binary;
    end
  end

endmodule // gray_count