HDLBits刷题之Circuits-＞Swquential Logic-＞More Circuits

Rule90

Rule 90 is a one-dimensional cellular automaton with interesting properties.

The rules are simple. There is a one-dimensional array of cells (on or off). At each time step, the next state of each cell is the XOR of the cell's two current neighbours. A more verbose way of expressing this rule is the following table, where a cell's next state is a function of itself and its two neighbours:

Left	Center	Right	Center's next state
1	1	1	0
1	1	0	1
1	0	1	0
1	0	0	1
0	1	1	1
0	1	0	0
0	0	1	1
0	0	0	0

(The name "Rule 90" comes from reading the "next state" column: 01011010 is decimal 90.)

In this circuit, create a 512-cell system (q[511:0]), and advance by one time step each clock cycle. The load input indicates the state of the system should be loaded with data[511:0]. Assume the boundaries (q[-1] and q[512]) are both zero (off).

Write your solution here

module top_module(
    input clk,
    input load,
    input [511:0] data,
    output [511:0] q ); 
    
    always@(posedge clk) begin
        if(load)
            q <= data;
        else begin
            q[0] <= 0^q[1];
            q[511] <= 0^q[510];
            q[510:1] <= q[511:2]^q[509:0];
        end
    end
endmodule

Rule110

Rule 110 is a one-dimensional cellular automaton with interesting properties (such as being Turing-complete).

There is a one-dimensional array of cells (on or off). At each time step, the state of each cell changes. In Rule 110, the next state of each cell depends only on itself and its two neighbours, according to the following table:

Left	Center	Right	Center's next state
1	1	1	0
1	1	0	1
1	0	1	1
1	0	0	0
0	1	1	1
0	1	0	1
0	0	1	1
0	0	0	0

(The name "Rule 110" comes from reading the "next state" column: 01101110 is decimal 110.)

In this circuit, create a 512-cell system (q[511:0]), and advance by one time step each clock cycle. The load input indicates the state of the system should be loaded with data[511:0]. Assume the boundaries (q[-1] and q[512]) are both zero (off).

Write your solution here

module top_module(
    input clk,
    input load,
    input [511:0] data,
    output [511:0] q
); 
    // A:{512,[511:2]} B:{511,[510:1],0} C:{[509:0],-1}
    // ABC'+AB'C+A'BC+A'BC'+A'B'C
    //=ABC'+A'B+B'C
    
    always@(posedge clk) begin
        if(load)
            q <= data;
        else begin
            q[0] <= q[1]&q[0]&1 | (~q[1]&q[0]) | (~q[0]&0);
        	q[511] <= 0&q[511]&(~q[510]) | 1&q[511] | (~q[511])&q[510];
            q[510:1] <= q[511:2]&q[510:1]&(~q[509:0]) | (~q[511:2]&q[510:1]) | (~q[510:1]&q[509:0]);
        end
    end
endmodule

Conwaylife

Conway's Game of Life is a two-dimensional cellular automaton.

The "game" is played on a two-dimensional grid of cells, where each cell is either 1 (alive) or 0 (dead). At each time step, each cell changes state depending on how many neighbours it has:

• 0-1 neighbour: Cell becomes 0.
• 2 neighbours: Cell state does not change.
• 3 neighbours: Cell becomes 1.
• 4+ neighbours: Cell becomes 0.

The game is formulated for an infinite grid. In this circuit, we will use a 16x16 grid. To make things more interesting, we will use a 16x16 toroid, where the sides wrap around to the other side of the grid. For example, the corner cell (0,0) has 8 neighbours: (15,1), (15,0), (15,15), (0,1), (0,15), (1,1), (1,0), and (1,15). The 16x16 grid is represented by a length 256 vector, where each row of 16 cells is represented by a sub-vector: q[15:0] is row 0, q[31:16] is row 1, etc. (This tool accepts SystemVerilog, so you may use 2D vectors if you wish.)

• load: Loads data into q at the next clock edge, for loading initial state.
• q: The 16x16 current state of the game, updated every clock cycle.

The game state should advance by one timestep every clock cycle.

John Conway, mathematician and creator of the Game of Life cellular automaton, passed away from COVID-19 on April 11, 2020.

Write your solution here

module top_module(
    input clk,
    input load,
    input [255:0] data,
    output [255:0] q ); 
//0-1 neighbour: Cell becomes 0.
//2 neighbours: Cell state does not change.
//3 neighbours: Cell becomes 1.
//4+ neighbours: Cell becomes 0.
//each row of 16 cells is represented by a sub-vector: q[15:0] is row 0,[31:16] is row 1
    
    //genvar循环用于产生多套电路，各套电路之间必须独立
    //genvar循环一定在过程块之外（always，initial），int循环一定在过程块内部。
    
    reg [3:0] sum;
    
    always@(posedge clk) begin
        if(load)
            q <= data;
        else
            for(int i=0;i<256;i=i+1) begin
                if(i == 0)
                    //注意 sum 赋值为 = 而不是 <=
                    //阻塞赋值(=)是顺序执行的，上面一条语句执行完之后，再执行下一行语句
                    sum = q[1]+q[16]+q[17]+q[15]+q[31]+q[240]+q[241]+q[255]; 
                else if(i == 15)
                    sum = q[14]+q[30]+q[31]+q[16]+q[0]+q[254]+q[255]+q[240];
                else if(i == 240)
                    sum = q[224]+q[225]+q[241]+q[239]+q[255]+q[0]+q[1]+q[15];
                else if(i == 255)
                    sum = q[238]+q[239]+q[254]+q[224]+q[240]+q[14]+q[15]+q[0];
                else if(i >=1 && i <= 14)
                    sum = q[i+1]+q[i-1]+q[239+i]+q[240+i]+q[241+i]+q[15+i]+q[16+i]+q[17+i];
                else if(i >= 241 && i<= 254)
                    sum = q[i+1]+q[i-1]+q[i-17]+q[i-16]+q[i-15]+q[i-241]+q[i-240]+q[i-239];
                else if(i%16 == 0)
                    sum = q[i-16]+q[i+16]+q[i-15]+q[i+17]+q[i+1]+q[i-1]+q[i+15]+q[i+31];
                else if(i%16 == 15)                                  
                    sum = q[i-1]+q[i-16]+q[i-17]+q[i+15]+q[i+16]+q[i+1]+q[i-15]+q[i-31];
                else
                    sum = q[i+1]+q[i-1]+q[i+16]+q[i-16]+q[i+17]+q[i-17]+q[i+15]+q[i-15];
                case(sum)
                    //非阻塞赋值(<=)第一行语句执行的时候，并不阻止下面语句的执行，并行执行。
                    4'b0010: q[i]<=q[i];
                    4'b0011: q[i]<=1;
                    default:q[i]<=0;
                endcase
            end
    end
    
endmodule