A funny thing about circuits: they work nothing like what we software developers expect them to. Specifically, it turns out that synchronous circuits, like memory, registers, counters etc. can only do one thing in one clock cycle. This means for example that you can't read the instruction and the subsequent immediate value in the same clock cycle. You have to split your work across multiple clock cycles.

In our simplified example, ROM is an asynchronous circuit, so we could read multiple values  In real life RAM takes many cycles to get the value from, and the faster the processor, the more cycles it need to wait for RAM.

Let's try to imagine how such logic could look like:

    module CPU(input iClk, input iRst, output [7:0] oAddressBus, input [7:0] iMemoryValue);

    localparam MVI=2'b00, MOV=2'b01, ALU=2'b10, ALI=2'b11;

    localparam B = 3'b000, C = 3'b001, D = 3'b010, E = 3'b011, 
               H = 3'b100, L = 3'b101, M = 3'b110, A = 3'b111;

    reg [7:0] _pc;

    //Now that we realized we need to do things across multiple clock cycles,
    //we'll need a register to keep track of where we are.
    reg _mode;
        NORMAL=1'b0, // reading the instruction
        READ_IMMED=1'b1; // reading the data value immediately following the instruction

    //also, need a register to remember the instruction once the memory has advanced to the next cell.
    reg [7:0] _instruction;

    always @(posedge iClk, posedge iRst)
                _pc = 8'h0;
                //always start in the Normal mode
                _mode = NORMAL;
        else begin
            $display("PC:%d", _pc);
            $display("mem:%d", iMemoryValue);

            //do a different thing depending on the current mode
                    if(iMemoryValue == 8'h0) $display("executing NOP!");
                    else case(iMemoryValue[7:6])
                        MVI: if(iMemoryValue[2:0] == M) begin
                                $display("initiating MVI");
                                //switch the mode so we can read the next memory value on the next clock cycle.
                                _mode = READ_IMMED;
                                //remember this is an MVI we're processing.
                                _instruction = iMemoryValue;
                             else $display("unknown instruction");
                            $display("unknown instruction");
                READ_IMMED: begin
                    //we know we're in the middle of an MVI instruction.
                    //now we can read the second operand from memory and execute the instruction.
                        B: $display("MVI B, %d", iMemoryValue);
                        C: $display("MVI C, %d", iMemoryValue);
                        D: $display("MVI D, %d", iMemoryValue);
                        E: $display("MVI E, %d", iMemoryValue);
                        H: $display("MVI H, %d", iMemoryValue);
                        L: $display("MVI L, %d", iMemoryValue);
                        M: $display("MVI M, %d", iMemoryValue);
                        A: $display("MVI A, %d", iMemoryValue);
                    //don't forget to switch back to the normal mode.
                    _mode = NORMAL;

            _pc = _pc + 1'b1;

    assign oAddressBus = _pc;


And the print out is:

--------------Tick           1---------------
PC:  x  
mem:  x  
--------------Tick           2---------------
PC:  x  
mem:  x  
--------------Tick           3---------------
PC:  x  
mem:  x  
--------------Tick           4---------------
PC:  0  
mem:  0  
executing NOP!  
--------------Tick           5---------------
PC:  1  
mem:  6  
initiating MVI  
--------------Tick           6---------------
PC:  2  
mem: 55  
MVI B,  55  
--------------Tick           7---------------
PC:  3  
mem: 14  
initiating MVI  
--------------Tick           8---------------
PC:  4  
MVI C, 255  
--------------Tick           9---------------
PC:  5  
mem:  1  
unknown instruction  
--------------Tick          10---------------
PC:  6  
mem:  x  
unknown instruction  
--------------Tick          11---------------
PC:  7  
mem:  x  
unknown instruction  
--------------Tick          12---------------
PC:  8  
mem:  x  
unknown instruction  
--------------Tick          13---------------
PC:  9  
mem:  x  
unknown instruction  

See how on tick 5 we're "initiating MVI" and on tick 6 we have a complete instruction, including the immediate value? I wonder what it would take to actually execute an instruction...