SHARE
TWEET

processor

a guest Jul 31st, 2018 82 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. `timescale 1ns / 1ps
  2.  
  3. module Main(
  4.     input clk,
  5.     input man_clk,
  6.     input MODE_clk,
  7.     input MODE_main,
  8.     input  [15:0] CMD,
  9.     input  [3:0] op1,
  10.     input  [3:0] op2,
  11.     input  [3:0] op3,
  12.     output [3:0] regA,
  13.     output [3:0] regB,
  14.     output [7:0] BUS
  15.     );
  16.     reg [3:0] addr;
  17.     reg [3:0] nxt_addr;
  18.     reg [3:0] CMD_op;
  19.     reg [3:0] op1_r;
  20.     reg [3:0] op2_r;
  21.     reg [3:0] op3_r;
  22.     reg [4:0] A;
  23.     reg [4:0] B;
  24.     reg [15:0] mem[15:0];
  25.     reg ZF;
  26.     reg GF;
  27.     reg LF;
  28.     reg [3:0] main_output;
  29.     reg [3:0] error;
  30.     integer i;
  31.     /*
  32.       error codes:
  33.         0000: no error
  34.         0001: no previous result "FETCH first argument didn't yield a result" *no op3_r @ addr-1*
  35.         0010: Invalid FETCH argument
  36.         0011: Invalid storage address, only the last 2 addresses can store values
  37.  
  38.  
  39.  
  40.     */
  41.  
  42.     //initialization of variables
  43.     initial begin
  44.       A = 4'b0000;
  45.       B = 4'b0000;
  46.       addr = 4'b0000;
  47.       nxt_addr = 4'b0000;
  48.     end
  49.  
  50.     always @ ( * ) begin
  51.       //converting inputs to the main array "mem"
  52.       mem[addr] = CMD;
  53.  
  54.       //setting up the registers
  55.       for(i=0;i<=3;i=i+1)
  56.       begin
  57.         CMD_op[i] = mem[addr][i];
  58.         op1_r[i]  = mem[addr][i+3];
  59.         op2_r  = mem[addr][i+8];
  60.         op3_r  = mem[addr][i+12];
  61.       end
  62.       //Operations and command main case
  63.       case (CMD_op)
  64.         //NOP
  65.         4'b0000: nxt_addr = addr + 4'b0001 ;
  66.         //ADD
  67.         4'b0001: begin
  68.                   op3_r = op1_r + op2_r;
  69.                   nxt_addr = addr + 4'b0001;
  70.                  end
  71.        //SUB
  72.        4'b0010: begin
  73.                  op3_r = op2_r - op1_r;
  74.                  nxt_addr = addr + 4'b0001;
  75.                 end
  76.       //AND
  77.       4'b0011: begin
  78.                 op3_r = op1_r & op2_r;
  79.                 if (op3_r == 4'b0000) begin
  80.                   ZF = 1'b1;
  81.                 end
  82.                 nxt_addr = addr + 4'b0001;
  83.  
  84.                end
  85.       //OR
  86.       4'b0100: begin
  87.                 op3_r = op1_r | op2_r;
  88.                 nxt_addr = addr + 4'b0001;
  89.                end
  90.       //JMP
  91.       4'b0101: nxt_addr = op1_r ;
  92.       //JMPZ
  93.       4'b0110: begin
  94.                 if(ZF)
  95.                   begin
  96.                     ZF = 1'b0;
  97.                     nxt_addr = op1_r;
  98.                   end
  99.                end
  100.       //JMPG
  101.       4'b0111: begin
  102.                 if (GF) begin
  103.                   GF = 1'b0;
  104.                   nxt_addr = op1_r;
  105.                 end else begin
  106.                   nxt_addr = addr + 4'b0001;
  107.                 end
  108.                 end
  109.  
  110.       //JMPL
  111.       4'b1000: begin
  112.                 if (LF) begin
  113.                   LF = 1'b0;
  114.                   nxt_addr = op1_r;
  115.                 end else begin
  116.                   nxt_addr = addr + 4'b0001;
  117.                 end
  118.                 end
  119.  
  120.       //LOADA
  121.       4'b1001: begin
  122.                 if (op1_r == 4'b0000) begin
  123.                   A = op2_r;
  124.                   if (!(op3_r == 4'b1110 || op3_r == 4'b1111)) begin
  125.                     error = 4'b0011;
  126.                   end
  127.                   mem[op3_r][0:3] = A;
  128.                 end else if (op1_r == 4'b0001) begin
  129.                   A = mem[addr - 4'b0001][12:15];
  130.                   if (!(op2_r == 4'b1110 || op2_r == 4'b1111)) begin
  131.                     error = 4'b0011;
  132.                   end
  133.                   mem[op2_r][0:3] = A;
  134.                 end
  135.  
  136.                end                                                                                                  /*LOADA,LOADB : op1_r is mode select, immediate value or previous operation's result
  137.                                                                                                                     depending on the mode, the immediate value mode considers the second argument as
  138.       //LOADB                                                                                                       the value and the third argument as the address of where it's gonna store the value*/
  139.       4'b1010: begin
  140.                 if (op1_r == 4'b0000) begin
  141.                   B = op2_r;
  142.                   if (!(op3_r == 4'b1110 || op3_r == 4'b1111)) begin
  143.                     error = 4'b0011;
  144.                   end
  145.                   mem[op3_r][0:3] = B;
  146.                 end else if (op1_r == 4'b0001) begin
  147.                   B = mem[addr - 4'b0001][12:15];
  148.                   if (!(op2_r == 4'b1110 || op2_r == 4'b1111)) begin
  149.                     error = 4'b0011;
  150.                   end
  151.                   mem[op2_r][0:3] = B;
  152.                 end
  153.                end
  154.  
  155.       //FETCH
  156.       /*
  157.       FETCH command arguments:
  158.         0000: previous result
  159.         0001: reg A
  160.         0010: reg B
  161.         0011: current address
  162.         0100: ZF
  163.         0101: GF
  164.         0110: LF
  165.       */
  166.       4'b1011: begin
  167.                 main_output = 4'b0000;
  168.                 case (op1_r)
  169.                   4'b0000: begin
  170.                             if (mem[addr - 4'b0001][0:3] == 4'b0001 || mem[addr - 4'b0001][0:3] == 4'b0010 || mem[addr - 4'b0001][0:3] == 4'b0011 || mem[addr - 4'b0001][0:3] == 4'b0100) begin
  171.                               main_output = mem[addr - 4'b0001][12:15];
  172.                             end else begin
  173.                               error = 4'b0001;
  174.                             end
  175.                            end
  176.                  4'b0001:  begin
  177.                             main_output = A;
  178.                            end
  179.                  4'b0010:  begin
  180.                             main_output = B;
  181.                            end
  182.                  4'b0011:  begin
  183.                             main_output = addr;
  184.                            end
  185.                  4'b0100:  begin
  186.                             main_output[0] = ZF;
  187.                            end
  188.                  4'b0101: begin
  189.                             main_output[0] = GF;
  190.                           end
  191.                  4'b0110: begin
  192.                             main_output[0] = LF;
  193.                           end
  194.                   default: error = 4'b0010 ;
  195.                 endcase
  196.  
  197.  
  198.  
  199.                end
  200.       //LD0
  201.  
  202.       //comp
  203.  
  204.       //CLR
  205.  
  206.         default: ;
  207.       endcase
  208.  
  209.     end
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.     /* The OP codes:
  225.         NOP:    0000
  226.         ADD:    0001
  227.         SUB:    0010
  228.         AND:    0011
  229.         OR:     0100
  230.         JMP:    0101
  231.         JMPZ:   0110
  232.         JMPG:   0111
  233.         JMPL:   1000
  234.         LOADA:  1001
  235.         LOADB:  1010
  236.         FETCH:  1011
  237.         LD0:    1100
  238.         LD1:    1101
  239.         CLR:    1111
  240.     */
  241. endmodule
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top