Complete an Algorithmic State Machine $($ASM$)$flowchart for your design.

$$Complete the datapath design for your design.

$$Complete the derivation for the controller$$s FSM$.$

$4$Simple $4-$bit processor

You will be designing a simple $4-$bit processor that has four $4-$bit registers, and it will have the

seven instructions shown in Table $1.$Note: that x and y in R y and R x are subscripts for the actual

registers R$0$R$3.$Each instruction is encoded with eight bits. Rather than having separate data

lines, the load instruction will carry its data with it within the instruction. The store instruction

simply puts the contents of a register into another register which has its output tied to LEDs. Note

that the last four bits of this instruction are ignored. The move instruction copies the contents of a

register to the other. Its two extra instruction bits are ignored. Finally, your ALU must support not

only add and subtract but also bitwise AND and NOT. Just like the Simple $8-$bit ALU calculator,

you may use behavioral Verilog for the arithmetic operations rather than using add and subtract

modules.

Operation Function Instruction Encoding

Load R x $,$Data R x Data $00,$R x $,$Data

Store R x $,$Data LEDs $[$R x $]01,$R x $,$XXXX

Move R x $,$Ry R x $[$R y $]10,$R x $,$R y $,$XX

Add R x $,$Ry R x $[$R x $]+[$R y $]11,$R x $,$R y $,00$

Sub R x $,$Ry R x $[$R x $][$R y $]11,$R x $,$R y $,01$

And R x $,$Ry R x $[$R x $]$& $[$R y $]11,$R x $,$R y $,10$

Not R x R x $![$R x $]11,$R x $,$XX$,11$

Table $1$: Instructions for the simple $4-$bit processor.

Your processor should be able to either execute instructions one at a time provided by the user

$($single$-$step mode$),$or execute a series of instructions stored in a read$-$only memory $($ROM$)($run

mode$).$A sample ROM Verilog module will be provided to you. You should assign a button to

select between these two modes of operation. In single$-$step mode, your program should be entered

via eight dip switches. A button should be used to indicate to the processor each time a new

instruction is setup and should be executed. In run mode, your processor should keep a program

counter that indexes into an array of instructions. This is already implemented in the ROM module

given to you. Your design should fetch and then execute one instruction at a time until it reaches

the end of the instruction array stored in the ROM module. Design an interesting program to run

on your processor. The program should cover as many operation types as possible. this is how far i got idk the next steps to take.