compiling the Kernel

multicycle processor

module alu(ctl, a, b, result, zero);
input [2:0] ctl;
input [31:0] a, b;
output [31:0] result;
output zero;

reg [31:0] result;
reg zero;

always @(a or b or ctl)
begin
case (ctl)
3'b000 : result = a & b; // AND
3'b001 : result = a | b; // OR
3'b010 : result = a + b; // ADD
3'b110 : result = a - b; // SUBTRACT
3'b111 : if (a < b) result = 32'd1;
else result = 32'd0; //SLT
default : result = 32'hxxxxxxxx;
endcase
if (result == 32'd0) zero = 1;
else zero = 0;
end
endmodule


module add32(a, b, result);
input [31:0] a, b;
output [31:0] result;

assign result = a + b;
endmodule


module alu_ctl(ALUOp, Funct, ALUOperation);
input [1:0] ALUOp;
input [5:0] Funct;
output [2:0] ALUOperation;
reg [2:0] ALUOperation;

// symbolic constants for instruction function code
parameter F_add = 6'd32;
parameter F_sub = 6'd34;
parameter F_and = 6'd36;
parameter F_or = 6'd37;
parameter F_slt = 6'd42;

// symbolic constants for ALU Operations
parameter ALU_add = 3'b010;
parameter ALU_sub = 3'b110;
parameter ALU_and = 3'b000;
parameter ALU_or = 3'b001;
parameter ALU_slt = 3'b111;

always @(ALUOp or Funct)
begin
case (ALUOp)
2'b00 : ALUOperation = ALU_add;
2'b01 : ALUOperation = ALU_sub;
2'b10 : case (Funct)
F_add : ALUOperation = ALU_add;
F_sub : ALUOperation = ALU_sub;
F_and : ALUOperation = ALU_and;
F_or : ALUOperation = ALU_or;
F_slt : ALUOperation = ALU_slt;
default ALUOperation = 3'bxxx;
endcase
default ALUOperation = 3'bxxx;
endcase
end
endmodule



//-----------------------------------------------------------------------------
// Title : MIPS Single-Cycle Control Unit
// Project : ECE 313 - Computer Organization
//-----------------------------------------------------------------------------
// File : control_single.v
// Author : John Nestor
// Organization : Lafayette College
//
// Created : November 2002
// Last modified : 7 January 2005
//-----------------------------------------------------------------------------
// Description :
// Control unit for the MIPS pipelined processor implementation described
// Section 6.3 of "Computer Organization and Design, 3rd ed."
// by David Patterson & John Hennessey, Morgan Kaufmann, 2004 (COD3e).
//
// It implements the function specified in Figure 6.25 on p. 401 of COD3e.
//
//-----------------------------------------------------------------------------

module control_pipeline(opcode, RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, ALUOp);
input [5:0] opcode;
output RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch;
output [1:0] ALUOp;
reg RegDst, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch;
reg [1:0] ALUOp;

parameter R_FORMAT = 6'd0;
parameter LW = 6'd35;
parameter SW = 6'd43;
parameter BEQ = 6'd4;

always @(opcode)
begin
case (opcode)
R_FORMAT :
begin
RegDst=1'b1; ALUSrc=1'b0; MemtoReg=1'b0; RegWrite=1'b1; MemRead=1'b0;
MemWrite=1'b0; Branch=1'b0; ALUOp = 2'b10;
end
LW :
begin
RegDst=1'b0; ALUSrc=1'b1; MemtoReg=1'b1; RegWrite=1'b1; MemRead=1'b1;
MemWrite=1'b0; Branch=1'b0; ALUOp = 2'b00;
end
SW :
begin
RegDst=1'bx; ALUSrc=1'b1; MemtoReg=1'bx; RegWrite=1'b0; MemRead=1'b0;
MemWrite=1'b1; Branch=1'b0; ALUOp = 2'b00;
end
BEQ :
begin
RegDst=1'bx; ALUSrc=1'b0; MemtoReg=1'bx; RegWrite=1'b0; MemRead=1'b0;
MemWrite=1'b0; Branch=1'b1; ALUOp = 2'b01;
end
default
begin
$display("control_single unimplemented opcode %d", opcode);
RegDst=1'b0; ALUSrc=1'b0; MemtoReg=1'b0; RegWrite=1'b0; MemRead=1'b0;
MemWrite=1'b0; Branch=1'b0; ALUOp = 2'b00;
end
endcase
end
endmodule



module mem32(clk, mem_read, mem_write, address, data_in, data_out);
input clk, mem_read, mem_write;
input [31:0] address, data_in;
output [31:0] data_out;
reg [31:0] data_out;

parameter BASE_ADDRESS = 25'd0; // address that applies to this memory - change if desired

reg [31:0] mem_array [0:31];
wire [4:0] mem_offset;
wire address_select;

assign mem_offset = address[6:2]; // drop 2 LSBs to get word offset

assign address_select = (address[31:7] == BASE_ADDRESS); // address decoding

always @(mem_read or address_select or mem_offset or mem_array[mem_offset])
begin

if (mem_read == 1'b1 && address_select == 1'b1)
begin
if ((address % 4) != 0)
$display($time, " rom32 error: unaligned address %d", address);
data_out = mem_array[mem_offset];
$display($time, " reading data: Mem[%h] => %h", address, data_out);
end
else data_out = 32'hxxxxxxxx;
end

// for WRITE operations
always @(posedge clk)
begin
if (mem_write == 1'b1 && address_select == 1'b1)
begin
$display($time, " writing data: Mem[%h] <= %h", address,data_in);
mem_array[mem_offset] <= data_in;
end
end

// initialize with some arbitrary values

integer i;
initial begin
for (i=0; i<7; i=i+1) mem_array[i] = i;
end
endmodule



module reg_file(clk, RegWrite, RN1, RN2, WN, RD1, RD2, WD);
input clk;
input RegWrite;
input [4:0] RN1, RN2, WN;
input [31:0] WD;
output [31:0] RD1, RD2;

reg [31:0] RD1, RD2;
reg [31:0] file_array [31:1];

always @(RN1 or file_array[RN1])
begin
if (RN1 == 0) RD1 = 32'd0;
else RD1 = file_array[RN1];
$display($time, " reg_file[%d] => %d (Port 1)", RN1, RD1);
end

always @(RN2 or file_array[RN2])
begin
if (RN2 == 0) RD2 = 32'd0;
else RD2 = file_array[RN2];
$display($time, " reg_file[%d] => %d (Port 2)", RN2, RD2);
end

always @(posedge clk)
if (RegWrite && (WN != 0))
begin
file_array[WN] <= WD;
$display($time, " reg_file[%d] <= %d (Write)", WN, WD);
end
endmodule


module mux2( sel, a, b, y );
parameter bitwidth=32;
input sel;
input [bitwidth-1:0] a, b;
output [bitwidth-1:0] y;

assign y = sel ? b : a;
endmodule


module rom32(address, data_out);
input [31:0] address;
output [31:0] data_out;
reg [31:0] data_out;

parameter BASE_ADDRESS = 25'd0; // address that applies to this memory

wire [5:0] mem_offset;
wire address_select;

assign mem_offset = address[7:2]; // drop 2 LSBs to get word offset

assign address_select = (address[31:8] == BASE_ADDRESS); // address decoding

always @(address_select or mem_offset)

begin
if ((address % 4) != 0) $display($time, " rom32 error: unaligned address %d", address);
if (address_select == 1)
begin
case (mem_offset)
5'd0 : data_out = { 6'd35, 5'd0, 5'd2, 16'd4 }; // lw $2, 4($0) r2=1
5'd1 : data_out = { 6'd35, 5'd0, 5'd3, 16'd8 }; // lw $3, 8($0) r3=2
5'd2 : data_out = { 6'd35, 5'd0, 5'd4, 16'd20 }; // lw $4, 20($0) r4=5
5'd3 : data_out = { 6'd0, 5'd0, 5'd0, 5'd5, 5'd0, 6'd32 }; // add $5, $0, $0 r5=0
5'd4 : data_out = 0; // no-op to stall until add is done
5'd5 : data_out = 0; // no-op to stall until add is done
5'd6 : data_out = 0; // no-op to stall until add is done
5'd7 : data_out = { 6'd0, 5'd5, 5'd2, 5'd5, 5'd0, 6'd32 }; // add $5, $5, $1 r5 = r6 + 1
5'd8 : data_out = 0; // no-op to stall until add is done
5'd9 : data_out = 0; // no-op to stall until add is done
5'd10 : data_out = 0; // no-op to stall until add is done
5'd11 : data_out = { 6'd0, 5'd4, 5'd5, 5'd6, 5'd0, 6'd42 }; // slt $6, $4, $5 is $5 > 54?
5'd12 : data_out = 0; // no-op to stall until slt is done
5'd13 : data_out = 0; // no-op to stall until slt is done
5'd14 : data_out = 0; // no-op to stall until slt is done
5'd15 : data_out = { 6'd4, 5'd6, 5'd0, -16'd9 }; // beq $6, $zero, -9 if not, go back 2
5'd16 : data_out = 32'b0; // no-op after branch
5'd17 : data_out = 32'b0; // no-op after branch
5'd18 : data_out = 32'b0; // no-op after branch
5'd19 : data_out = { 6'd43, 5'd0, 5'd5, 16'd0 }; // MEM[0] = $5
5'd20 : data_out = { 6'd4, 5'd0, 5'd0, -16'd18 }; // beq $0, $0, -18 restart loop at word 3
// add more cases here as desired
default data_out = 32'hxxxx;
endcase

$display($time, " reading data: rom32[%h] => %h", address, data_out);

end
end
endmodule



module reg32 (clk, reset, d_in, d_out);
input clk, reset;
input [31:0] d_in;
output [31:0] d_out;
reg [31:0] d_out;

always @(posedge clk)
begin
if (reset) d_out <= 0;
else d_out <= d_in;
end

endmodule



module mips_pipeline(clk, reset);
input clk, reset;

// ********************************************************************
// Signal Declarations
// ********************************************************************

// IF Signal Declarations

wire [31:0] IF_instr, IF_pc, IF_pc_next, IF_pc4;

// ID Signal Declarations

reg [31:0] ID_instr, ID_pc4; // pipeline register values from EX

wire [5:0] ID_op, ID_funct;
wire [4:0] ID_rs, ID_rt, ID_rd;
wire [15:0] ID_immed;
wire [31:0] ID_extend, ID_rd1, ID_rd2;

assign ID_op = ID_instr[31:26];
assign ID_rs = ID_instr[25:21];
assign ID_rt = ID_instr[20:16];
assign ID_rd = ID_instr[15:11];
assign ID_immed = ID_instr[15:0];

wire ID_RegWrite, ID_Branch, ID_RegDst, ID_MemtoReg, // ID Control signals
ID_MemRead, ID_MemWrite, ID_ALUSrc;
wire [1:0] ID_ALUOp;

// EX Signals

reg [31:0] EX_pc4, EX_extend, EX_rd1, EX_rd2;
wire [31:0] EX_offset, EX_btgt, EX_alub, EX_ALUOut;
reg [4:0] EX_rt, EX_rd;
wire [4:0] EX_RegRd;
wire [5:0] EX_funct;

reg EX_RegWrite, EX_Branch, EX_RegDst, EX_MemtoReg, // EX Control Signals
EX_MemRead, EX_MemWrite, EX_ALUSrc;

wire EX_Zero;

reg [1:0] EX_ALUOp;
wire [2:0] EX_Operation;

// MEM Signals

wire MEM_PCSrc;

reg MEM_RegWrite, MEM_Branch, MEM_MemtoReg,
MEM_MemRead, MEM_MemWrite, MEM_Zero;

reg [31:0] MEM_btgt, MEM_ALUOut, MEM_rd2;
wire [31:0] MEM_memout;
reg [5:0] MEM_RegRd;

// WB Signals

reg WB_RegWrite, WB_MemtoReg; // WB Control Signals

reg [31:0] WB_memout, WB_ALUOut;
wire [31:0] WB_wd;
reg [4:0] WB_RegRd;

// ********************************************************************
// IF Stage
// ********************************************************************

// IF Hardware

reg32 IF_PC(clk, reset, IF_pc_next, IF_pc);

add32 IF_PCADD(IF_pc, 32'd4, IF_pc4);

mux2 #(32) IF_PCMUX(MEM_PCSrc, IF_pc4, MEM_btgt, IF_pc_next);

rom32 IMEM(IF_pc, IF_instr);

always @(posedge clk) // IF/ID Pipeline Register
begin
if (reset)
begin
ID_instr <= 0;
ID_pc4 <= 0;
end
else begin
ID_instr <= IF_instr;
ID_pc4 <= IF_pc4;
end
end

// ********************************************************************
// ID Stage
// ********************************************************************

reg_file RFILE(clk, WB_RegWrite, ID_rs, ID_rt, WB_RegRd, ID_rd1, ID_rd2, WB_wd);

// sign-extender
assign ID_extend = { {16{ID_immed[15]}}, ID_immed };

control_pipeline CTL(.opcode(ID_op), .RegDst(ID_RegDst),
.ALUSrc(ID_ALUSrc), .MemtoReg(ID_MemtoReg),
.RegWrite(ID_RegWrite), .MemRead(ID_MemRead),
.MemWrite(ID_MemWrite), .Branch(ID_Branch),
.ALUOp(ID_ALUOp));


always @(posedge clk) // ID/EX Pipeline Register
begin
if (reset)
begin
EX_RegDst <= 0;
EX_ALUOp <= 0;
EX_ALUSrc <= 0;
EX_Branch <= 0;
EX_MemRead <= 0;
EX_MemWrite <= 0;
EX_RegWrite <= 0;
EX_MemtoReg <= 0;
EX_RegDst <= 0;
EX_ALUOp <= 0;
EX_ALUSrc <= 0;
EX_Branch <= 0;
EX_MemRead <= 0;
EX_MemWrite <= 0;
EX_RegWrite <= 0;
EX_MemtoReg <= 0;

EX_pc4 <= 0;
EX_rd1 <= 0;
EX_rd2 <= 0;
EX_extend <= 0;
EX_rt <= 0;
EX_rd <= 0;
end
else begin
EX_RegDst <= ID_RegDst;
EX_ALUOp <= ID_ALUOp;
EX_ALUSrc <= ID_ALUSrc;
EX_Branch <= ID_Branch;
EX_MemRead <= ID_MemRead;
EX_MemWrite <= ID_MemWrite;
EX_RegWrite <= ID_RegWrite;
EX_MemtoReg <= ID_MemtoReg;
EX_RegDst <= ID_RegDst;
EX_ALUOp <= ID_ALUOp;
EX_ALUSrc <= ID_ALUSrc;
EX_Branch <= ID_Branch;
EX_MemRead <= ID_MemRead;
EX_MemWrite <= ID_MemWrite;
EX_RegWrite <= ID_RegWrite;
EX_MemtoReg <= ID_MemtoReg;

EX_pc4 <= ID_pc4;
EX_rd1 <= ID_rd1;
EX_rd2 <= ID_rd2;
EX_extend <= ID_extend;
EX_rt <= ID_rt;
EX_rd <= ID_rd;
end
end

// ********************************************************************
// EX Stage
// ********************************************************************

// branch offset shifter
assign EX_offset = EX_extend << 2;

assign EX_funct = EX_extend[5:0];

add32 EX_BRADD(EX_pc4, EX_offset, EX_btgt);

mux2 #(32) ALUMUX(EX_ALUSrc, EX_rd2, EX_extend, EX_alub);

alu EX_ALU(EX_Operation, EX_rd1, EX_alub, EX_ALUOut, EX_Zero);

mux2 #(5) EX_RFMUX(EX_RegDst, EX_rt, EX_rd, EX_RegRd);

alu_ctl EX_ALUCTL(EX_ALUOp, EX_funct, EX_Operation);

always @(posedge clk) // EX/MEM Pipeline Register
begin
if (reset)
begin
MEM_Branch <= 0;
MEM_MemRead <= 0;
MEM_MemWrite <= 0;
MEM_RegWrite <= 0;
MEM_MemtoReg <= 0;
MEM_Zero <= 0;

MEM_btgt <= 0;
MEM_ALUOut <= 0;
MEM_rd2 <= 0;
MEM_RegRd <= 0;
end
else begin
MEM_Branch <= EX_Branch;
MEM_MemRead <= EX_MemRead;
MEM_MemWrite <= EX_MemWrite;
MEM_RegWrite <= EX_RegWrite;
MEM_MemtoReg <= EX_MemtoReg;
MEM_Zero <= EX_Zero;

MEM_btgt <= EX_btgt;
MEM_ALUOut <= EX_ALUOut;
MEM_rd2 <= EX_rd2;
MEM_RegRd <= EX_RegRd;
end
end

// ********************************************************************
// MEM Stage
// ********************************************************************

mem32 MEM_DMEM(clk, MEM_MemRead, MEM_MemWrite, MEM_ALUOut, MEM_rd2, MEM_memout);

and MEM_BR_AND(MEM_PCSrc, MEM_Branch, MEM_Zero);

always @(posedge clk) // MEM/WB Pipeline Register
begin
if (reset)
begin
WB_RegWrite <= 0;
WB_MemtoReg <= 0;
WB_ALUOut <= 0;
WB_memout <= 0;
WB_RegRd <= 0;
end
else begin
WB_RegWrite <= MEM_RegWrite;
WB_MemtoReg <= MEM_MemtoReg;
WB_ALUOut <= MEM_ALUOut;
WB_memout <= MEM_memout;
WB_RegRd <= MEM_RegRd;
end
end

// ********************************************************************
// WB Stage
// ********************************************************************

mux2 #(32) WB_WRMUX(WB_MemtoReg, WB_ALUOut, WB_memout, WB_wd);


endmodule

NS 2 assignment (TCP traffic flow)

set ns [new Simulator]
set nf [open out.nam w]
$ns namtrace-all $nf
proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam out.nam &
exit 0
}
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]

$ns duplex-link $n0 $n1 1Mb 20ms DropTail
$ns duplex-link $n0 $n2 1Mb 20ms DropTail
$ns duplex-link $n1 $n3 1Mb 20ms DropTail
$ns duplex-link $n2 $n4 1Mb 20ms DropTail
$ns duplex-link $n4 $n5 1Mb 20ms DropTail
$ns duplex-link $n3 $n5 1Mb 20ms DropTail


set u0 [new Agent/TCP]
set u1 [new Agent/TCPSink]
set u2 [new Agent/TCP]
set u3 [new Agent/TCPSink]



$ns attach-agent $n0 $u0
$ns attach-agent $n5 $u1
$ns attach-agent $n2 $u2
$ns attach-agent $n3 $u3


$ns connect $u0 $u1
$ns connect $u2 $u3

set c0 [new Application/Traffic/CBR]
$c0 set packetSize_ 500
$c0 set interval_ 0.005
$c0 attach-agent $u0
$ns at 0.5 "$c0 start"
$ns at 9.0 "$c0 stop"

set c1 [new Application/Traffic/CBR]
$c1 set packetSize_ 500
$c1 set interval_ 0.005
$c0 attach-agent $u2


$ns at 10.0 "finish"
$ns run



save it with a name simulation.tcl
At terminal type ns2 simulation.tcl

mips single cycle processor

/*
This code is for 4 bit I/O. convert it to 32 I/O.
*/
module add (out,a,b);
output [31:0] out;
input [31:0] a,b;

assign out=a+b;
endmodule


/*
This code is for 4 bit I/O. convert it to 32 I/O.
*/

module add_4 (out , in);
output [31:0] out;
input [31:0] in;

assign out= in + 4;
endmodule

module ALU ( OUT , ALU_zero , A , B , ALU_Control );

output [31:0] OUT ;
output ALU_zero ;
input [31:0] A , B;
input [2:0] ALU_Control ;

reg [31:0] OUT;

assign ALU_zero = ~ ( | OUT ) ; // ALU_zero = 1 when OUT =0 ;

wire [31:0] DIFF = A - B ;

always @ ( A or B or ALU_Control or DIFF)

case(ALU_Control)

3'b000 : OUT = A & B ;
3'b001 : OUT = A | B ;
3'b010 : OUT = A + B ;
3'b110 : OUT = DIFF ;
3'b111 : OUT = { {31{1'b0}} , DIFF[31] } ; // OUT =00...001 when A < B
///3'b111 for slt instruction // DIFF[31] =1 when A < B
default : OUT = 32'hxxxxxxxx ;
endcase

endmodule


module ALU_Control(Operation, F, ALUop);
output [2:0] Operation;
input [5:0] F;
input [1:0] ALUop;

assign Operation[2] = (F[1] & ALUop[1]) | (ALUop[0]);

assign Operation[1] = (~ALUop[1]) | (~F[2]);

assign Operation[0] = (F[3] | F[0]) & (ALUop[1]);



// use always block or assign statements
// only 3 statements are required



endmodule


module Control ( RegDST ,
Branch ,
MemRead ,
MemtoReg ,
ALUOP ,
MemWrite ,
ALUSrc ,
RegWrite ,

op );

output RegDST,ALUSrc,MemtoReg,RegWrite,MemRead,MemWrite,Branch;
output[1:0] ALUOP;
input [5:0] op ;

wire r_format,lw,sw,beq,addi;

assign r_format =(~op[5] ) & (~op[4] ) & (~op[3] ) & (~op[2] ) & (~op[1]) &(~op[0] ) ;
assign lw =(op[5] ) & (~op[4] ) & (~op[3] ) & (~op[2] ) & (op[1] ) &(op[0] ) ;
assign sw =(op[5] ) & (~op[4] ) & (op[3] ) & (~op[2] ) & (op[1]) &(op[0] ) ;
assign beq =(~op[5] ) & (~op[4] ) & (~op[3] ) & (op[2] ) & (~op[1]) &(~op[0] ) ;
assign addi =(~op[5] ) & (~op[4] ) & (op[3] ) & (~op[2] ) & (~op[1]) &(~op[0] ) ;
assign RegDST=r_format,
ALUSrc= (lw)|(sw)|(addi),
MemtoReg=lw,
RegWrite=r_format|lw|addi,
MemRead= lw ,
MemWrite=sw ,
Branch=beq;

assign ALUOP[1]=r_format;
assign ALUOP[0]=beq ;



endmodule


/*
This code is for 4*4 data_memory. convert it to 16*32 data_memory.
*/
module data_memory ( data_out , address,data_in ,wr,clk ) ;
output [31:0] data_out;
input [31:0] data_in;
input [3:0] address;
input wr,clk;

reg [31:0] data_mem [15:0];

assign data_out=data_mem[address];

always @ (posedge clk )
if (wr==1)
data_mem[address]=data_in;

endmodule


/*
This code is for 4*4 instruction_memory. convert it to 16*32 instruction_memory.
*/

module instruction_memory ( data_out , address) ;
output [31:0] data_out ;
reg [31:0] data_out ;

input [3:0] address ;
wire [3:0] address ;

//}} End of automatically maintained section
always@( address )
case(address)
0: data_out=32'h20010004;
1: data_out=32'h20020008;
2: data_out=32'h00411820;
3: data_out=32'h00622022;
4: data_out=32'h0083282a;
5: data_out=32'hac020004;
6: data_out=32'h8c020004;
7: data_out=32'h00000000;
8: data_out=32'h00000000;
9: data_out=32'h00000000;
10: data_out=32'h00000000;
11: data_out=32'h00000000;
12: data_out=32'h00000000;
13: data_out=32'h00000000;
14: data_out=32'h00000000;
15: data_out=32'h00000000;
endcase
endmodule


module mux_5to1(out, a,b,sel);
output [4:0] out;
input [4:0] a,b;
input sel;
reg [4:0] out;
always @ (sel or a or b)
if(sel==0)
out = a;
else
out = b;
endmodule


/*
This code is for 4 bit instruction lines. convert them to 32 bit instruction lines.
*/
module mux_32to1(out, a,b,sel);
output [31:0] out;
input [31:0] a,b;
input sel;
reg [31:0] out;
always @ (sel or a or b)
if(sel==0)
out = a;
else
out = b;
endmodule


/*
This code is for 4 bit I/O. convert it to 32 I/O.
*/

module pc (out , in ,clk, rst);
output [31:0] out;
input [31:0] in;
input clk,rst;
reg [31:0]out;
always @ (posedge clk or posedge rst)
if(rst==1)
out = 0;
else
out = in;
endmodule


This code is for 4*4 register file. convert it to 32*32 register file.
*/
module register_file (data_out1,data_out2,data_in,wr,wr_enable,rd1,rd2,clk,rst);
output [31:0] data_out1,data_out2;
input [31:0] data_in;
input [4:0] wr,rd1,rd2;
input wr_enable,clk,rst;
reg [31:0] registers [31:0];

wire [31:0] R0 = registers[0],
R1 = registers[1],
R2 = registers[2],
R3 = registers[3],
R4 = registers[4],
R5 = registers[5],
R6 = registers[6];

assign data_out1=registers[rd1];
assign data_out2=registers[rd2];
integer i;
always@(posedge clk or posedge rst)
if(rst==1) begin for(i=0;i<=31;i=i+1) registers[i]<=0;end
else if (wr_enable==1)
registers[wr]<=data_in;

initial begin
registers[0] = 0;
registers[1] = 4;
registers[2] = 8;
registers[3] = 2;
end

endmodule


This code is for 16 bit I/O. convert it to 32 bit I/O.
*/

module shift_left2( out , in) ;
output [31:0] out;
input [31:0] in;

assign out=in << 2;
endmodule


module Sign_Ext (out , in );

output [31:0] out;
input [15:0] in;

assign out = { {16{in[15]}} , in[15:0] };

endmodule



module single_cycle_microprocessor (processor_out , clk , rst );

output [31:0] processor_out;
input clk , rst;

wire [31:0] pc_out,add4_out,instruction;
wire [3:0] frm_pc;
wire [5:0] opcode;
wire [4:0] Rs , Rt , Rd , mux1_out;
wire [15:0] Imm;
wire [5:0] FC;
wire [1:0] ALUOP;
wire [31:0] regA_out,regB_out,mux2_out;
wire [2:0] Operation;
wire [31:0] sign_out,sh_left_out,add_out,mux3_out ;
wire [31:0] ALU_OUT,data_out,mux4_out;
wire [3:0] ALU_Out_Adress;
wire PCSrc;
wire Branch , ALU_zero;


assign frm_pc = pc_out[5:2];
assign Rs = instruction[25:21];
assign Rt = instruction[20:16];
assign Rd = instruction[15:11];
assign opcode = instruction[31:26];
assign Imm = instruction[15:0];
assign FC = Imm[5:0];
assign ALU_Out_Adress = ALU_OUT[5:2];
assign PCSrc = Branch & ALU_zero;
assign processor_out=mux4_out;

pc PC(.out(pc_out) , .in(mux3_out) ,.clk(clk), .rst(rst));

add_4 ADD_4(.out(add4_out) , .in(pc_out));

instruction_memory INST_MEM ( .data_out(instruction) , .address(frm_pc)) ;

mux_5to1 MUX_1(.out(mux1_out),.a(Rt),.b(Rd),.sel(RegDST));

Control CONTROL(.RegDST(RegDST) , .Branch(Branch) , .MemRead(MemRead) , .MemtoReg(MemtoReg) ,.ALUOP(ALUOP) ,.MemWrite(MemWrite) ,.ALUSrc(ALUSrc) ,.RegWrite(RegWrite) ,.op(opcode) );

register_file REGISTER(.data_out1(regA_out),.data_out2(regB_out),.data_in(mux4_out),.wr(mux1_out),.wr_enable(RegWrite),.rd1(Rs),.rd2(Rt),.clk(clk),.rst(rst));

Sign_Ext SIGN_EXT(.out (sign_out) , .in(Imm) );

mux_32to1 MUX_2(.out(mux2_out),.a(regB_out),.b(sign_out),.sel(ALUSrc));

ALU_Control ALU_CONTROL(.Operation(Operation), .F(FC), .ALUop(ALUOP));

ALU ALU_32bit( .OUT(ALU_OUT) ,.ALU_zero( ALU_zero) , .A(regA_out),.B(mux2_out) , .ALU_Control(Operation) );

shift_left2 Shift_Left_2(.out(sh_left_out) , .in(sign_out)) ;

add ADD_32bit(.out(add_out),.a(add4_out),.b(sh_left_out));

mux_32to1 MUX_3(.out(mux3_out), .a(add4_out),.b(add_out),.sel(PCSrc));

data_memory DATA_MEM(.data_out( data_out) ,.address( ALU_Out_Adress) ,.data_in(regB_out) ,.wr(MemWrite),.clk(clk) ) ;

mux_32to1 MUX_4(.out(mux4_out),.a(ALU_OUT),.b(data_out),.sel(MemtoReg));


endmodule

Line follower code

#include

#include

sbit en1 =P1_0;
sbit en2 =P1_1 ;
sbit l1 = P1_4;
sbit l2 = P1_5;

sbit r1 = P1_2;
sbit r2 = P1_3;

sbit sen4 = P3_0;
sbit sen3 = P3_1;
sbit sen2 = P3_2;
sbit sen1 = P3_3;

void main()

{

r1 = 1;

r2 = 0;

l1 = 1;

l2 = 0;

while(1)

{

while(sen2==1)

{

en1 = 1;

en2 = 1;

}

while(sen3==1)

{

en1 = 1;

en2 = 0;

}

while(sen1==1)

{

en1 = 0;

en2 = 1;

}

}

}