  ## Counters 2 - Special counters

##### Modulus counters

A modulus counter is a binary counter that rolls back before its natural end value. For example, let's say you want a modulus 10 counter (counts from 0 to 9), you can write this.

```reg [3:0] cnt = 0;  // we need 4 bits to be able to reach 9

always @(posedge clk)
if(cnt==9)
cnt <= 0;
else
cnt <= cnt+1;
```
or this (a little more compact)
```reg [3:0] cnt = 0;
always @(posedge clk) cnt <= (cnt==9) ? 0 : cnt+1;
```

Now a little of (free) optimization is available if you realize that we don't actually need to compare all the 4 bits of the counter to 9. The code below uses only bit 0 and bit 3 in the comparison.

```always @(posedge clk) cnt <= ((cnt & 9)==9) ? 0 : cnt+1;
```
##### Gray counters

A Gray counter is a binary counter where only one bit changes at a time.
Here's how a 4bit Gray counter goes.

```0000
0001
0011
0010
0110
0111
0101
0100
1100
1101
1111
1110
1010
1011
1001
1000
and then wraps back to 0000...
```

Gray code is useful to send values across clock domains (this way it has an uncertainty of only 1).

The easiest way to create a Gray counter is to first make a binary counter, and then convert the value to Gray.

```module GrayCounter(
input clk,
output [3:0] cnt_gray
);

reg [3:0] cnt = 0;
always @(posedge clk) cnt <= cnt+1;  // 4bit binary counter

assign cnt_gray = cnt ^ cnt[3:1];  // then convert to gray
endmodule
```

It is also possible to create a native Gray counter.

```module GrayCounter(
input clk,
output reg [3:0] cnt_gray = 0
);

wire [3:0] cnt_cc = {cnt_cc[2:1] & ~cnt_gray[1:0], ^cnt_gray, 1'b1};  // carry-chain type logic
always @(posedge clk) cnt_gray <= cnt_gray ^ cnt_cc ^ cnt_cc[3:1];
endmodule
```