Is there an accepted way to get a Gray Code counter in Chisel?

Question

I'm looking to write counters in Chisel3 that will be used to address subunits. If the counter matches some register in a subunit then the subunit fires, otherwise it doesn't.

I would much rather have the addresses cycle in Gray code than in binary. It's easy enough to write a binary counter in Chisel, but I see no provision for a Gray code counter.

I can write a new type akin to Uint and Sint, but I'm reluctant to reinvent it if it's already out there. Yet I don't see anything in the cookbook or other docs about Gray code. Github just turns up a Minecraft-oriented repo (because it matches "chisel") There is existing stuff for VHDL but I want to express this in Chisel.

So have I missed a resource that would provide a Gray counter in Chisel? Failing that, is building a new type akin to Uint a reasonable way to proceed?

Answer 1

I did a quick look around and didn't find anything quite like what you're looking for. The closest thing I could find was a simple Gray counter in rocket-chip (https://github.com/chipsalliance/rocket-chip/blob/29ce00180f2a69947546d6385a1da86cbc584376/src/main/scala/util/AsyncQueue.scala#L49) but it uses regular binary counting and then just returns a UInt in Gray code. It also doesn't take advantage of any Scala type safety.

I think this would be a reasonable thing to build, and if you want you could contribute it to https://github.com/freechipsproject/ip-contributions for increased visibility.

I think if you wanted a proper GrayCode type, it would be reasonable to create a custom type. Unfortunately, there is no way to extend Data for a Bits-like type (all of the types in that hierarchy are sealed), but you could create a custom Bundle that wraps a UInt and then implement your own set of operations, eg.

class GrayCode(private val w: Int) extends Bundle {
  val value = UInt(w.W)

  def +(that: GrayCode): GrayCode = ???
}
object GrayCode {
  // Lets you write GrayCode(4.W)
  // Width is defined in chisel3.internal.firrtl though which is awkward...
  def apply(width: Width): GrayCode = ???
}

This is just a quick sketch. The DSP Tools library has examples of custom types for DSP: https://github.com/ucb-bar/dsptools

They tend to use Scala Typeclasses a lot which is a more advanced Scala feature. Just mentioning in case some of the syntax in their looks alien.

Answer 2

You might take a look at this link programmersought gray code fifo it seems like it may be relevant but I am not familiar with it otherwise.

Answer 3

As with Jack I'm not familiar with the math needed to actually increment values in Gray code, but something like the following code would convert Gray code to binary, add, then convert it back to Gray code. I'm not sure if the Vec() code below would work correctly but should make the idea clear.

import chisel3._
import chisel3.util._

class GrayCode(private val w: Int) extends Bundle {
  val value = UInt(w.W)

  def bin2grey(x : UInt) : UInt = {
    x ^ (x >> 1.U)
  }
  def grey2bin(x : UInt, n : Int) : UInt = {
    val tmp = Wire(Vec(n, Bool()))
    tmp(n-1) := x(n-1)
    for (i <- 0 to (n-2)) {
      tmp(i) := x(i) ^ tmp(i+1)
    }
    Cat(tmp.reverse)
  }
  def +(that: GrayCode): GrayCode = {
    val sum = new GrayCode(w)
    sum.value := grey2bin(bin2grey(this.value) + bin2grey(that.value), w)
    sum
  }
}

Answer 4

It seems like all implementations here use binary-to-Gray conversion. For asynchronous FIFOs, this only works if the Gray code is latched just before crossing clock domains. What if you want a counter that actually counts Gray codes instead of converting binary values to Gray codes?

One option is to convert Gray to binary, add, then convert back to Gray and store the result. The other is to use custom arithmetic to calculate the next Gray value in the sequence. The typical sequence is a reflected-binary Gray code, but others exist.

The code below implements a Gray code counter using a reflected-binary Gray code. It was adapted from this blog post. It only counts up. It works like the Chisel Counter object, except it adds support for a synchronous reset and custom register name. It returns the counter and wrap status.

import chisel3._
import chisel3.util._

// a Gray counter counts in Gray code
object GrayCounter {

  // Gray unit cell
  // b is the current state of this bit
  // returns (t, z_o) where t is the next state of this bit
  def grayCell(b: Bool, q_i: Bool, z_i: Bool, enable: Bool, parity: Bool): (Bool, Bool) = { 
    (b ^ (enable && q_i && z_i && parity), (!q_i) && z_i)
  }   

  // cond = counts when true
  // n = count value, must be a power of 2
  // synchronousReset = resets counter to 0
  // name = name for this counter
  def apply(cond: Bool, n: Int, synchronousReset: Bool = false.B, name: String = null) = { 
    require(isPow2(n), s"Gray counter must have power-of-2 length (you asked for $n)")
    require(n > 2, s"Gray counter minimum count is 4 (you asked for $n)")
    val counter = RegInit(0.U(log2Ceil(n).W))
    if (name != null) {
      counter.suggestName(name)
    }   
    val counterNext = Wire(Vec(log2Ceil(n), Bool()))
    counter := counterNext.asUInt
    val z_wires = Wire(Vec(log2Ceil(n), Bool()))
    val parity = counter.xorR
    for (i <- 0 until log2Ceil(n)) {
      if (i == 0) {
        val grayCellOut = grayCell(counter(i), true.B, true.B, cond, !parity)
        counterNext(i) := grayCellOut._1
        z_wires(i) := grayCellOut._2
      } else {
        val grayCellOut = grayCell(counter(i), counter(i-1) || (i == log2Ceil(n)-1).B, 
            z_wires(i-1) || (i == 1).B, cond, parity)
        counterNext(i) := grayCellOut._1
        z_wires(i) := grayCellOut._2
      }   
    }   
    when (synchronousReset) {
      counter := 0.U 
    }   
    val wrap = counter === (n/2).U && cond
    (counter, wrap)
  }   

}