Advertisement
kekellner

decoder.v (Versión 2)

Nov 15th, 2024 (edited)
156
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. module decoder (
  2.     input [15:0] instrReg,
  3.     input Z_decode,
  4.     input C_decode,
  5.     output S,
  6.     output [2:0] F,
  7.     output [7:0] address1,
  8.     output [7:0] address2,
  9.     output ramWE,
  10.     output loadPC,
  11.     output instrEN,
  12.     output PCinstr,
  13.     output [6:0] k
  14. );
  15.  
  16.     reg _S, _ramWE, _loadPC, _PCinstr, _instrEN;
  17.     reg [2:0] _F;
  18.     reg [6:0] _k;
  19.     reg [7:0] _address1, _address2;
  20.     wire [3:0] instruction;
  21.  
  22.     assign instruction = instrReg[15:12];
  23.  
  24.     initial begin
  25.         _S = 0;
  26.         _ramWE = 0;
  27.         _loadPC = 0;
  28.         _PCinstr = 0;
  29.         _instrEN = 1;
  30.         _F = 0;
  31.         _k = 0;
  32.         _address1 = 0;
  33.         _address2 = 0;
  34.     end
  35.  
  36.     parameter _pasaRrk = 3'b000;
  37.     parameter _suma = 3'b001;
  38.     parameter _and = 3'b010;
  39.     parameter _resta = 3'b011;
  40.     parameter _xor = 3'b100;
  41.     parameter _pasaRd = 3'b101;
  42.     parameter _or = 3'b110;
  43.  
  44.     always @(*) begin
  45.         casez (instrReg)
  46.             // ADD
  47.             16'b0000_00??_????_????: begin
  48.                 _S = 1;  // Dejar pasar RrK
  49.                 _ramWE = 1;  // Habilitar escritura en RAM
  50.                 _loadPC = 0;
  51.                 _PCinstr = 0;
  52.                 _instrEN = 1;
  53.                 _F = _suma;
  54.                 _k = 0;
  55.                 _address1 = {3'b000, instrReg[8:4]};
  56.                 _address2 = {3'b000, instrReg[9], instrReg[3:0]};
  57.             end
  58.             // AND
  59.             16'b0001_00??_????_????: begin
  60.                 _S = 1;  // Dejar pasar RrK
  61.                 _ramWE = 1;  // Habilitar escritura en RAM
  62.                 _loadPC = 0;
  63.                 _PCinstr = 0;
  64.                 _instrEN = 1;
  65.                 _F = _and;
  66.                 _k = 0;
  67.                 _address1 = {3'b000, instrReg[8:4]};
  68.                 _address2 = {3'b000, instrReg[9], instrReg[3:0]};
  69.             end
  70.             // SUB
  71.             16'b0010_00??_????_????: begin
  72.                 _S = 1;  // Dejar pasar RrK
  73.                 _ramWE = 1;  // Habilitar escritura en RAM
  74.                 _loadPC = 0;
  75.                 _PCinstr = 0;
  76.                 _instrEN = 1;
  77.                 _F = 3'b011;  // ALU -> SUB
  78.                 _k = 0;
  79.                 _address1 = {3'b000, instrReg[8:4]};
  80.                 _address2 = {3'b000, instrReg[9], instrReg[3:0]};
  81.             end
  82.             // CLR
  83.             16'b0011_00??_????_????: begin
  84.                 _S = 1;  // Dejar pasar RrK
  85.                 _ramWE = 1;  // Habilitar escritura en RAM
  86.                 _loadPC = 0;
  87.                 _PCinstr = 0;
  88.                 _instrEN = 1;
  89.                 _F = 3'b100;  // ALU -> XOR
  90.                 _k = 0;
  91.                 _address1 = {3'b000, instrReg[8:4]};
  92.                 _address2 = {3'b000, instrReg[9], instrReg[3:0]};
  93.             end
  94.             // ANDI
  95.             16'b0100_????_????_????: begin
  96.                 _S = 0;  // Dejar pasar RrK
  97.                 _ramWE = 1;  // Habilitar escritura en RAM
  98.                 _loadPC = 0;
  99.                 _PCinstr = 0;
  100.                 _instrEN = 1;
  101.                 _F = 3'b010;  // AND
  102.                 _k = 0;
  103.                 _address1 = {4'b0001, instrReg[7:4]};
  104.                 _address2 = 0;
  105.             end
  106.             // BRBS
  107.             16'b0101_00??_????_????: begin
  108.                 case (instrReg[2:0])
  109.                     3'b000:
  110.                     if (C_decode == 1) begin
  111.                         _S = 0;
  112.                         _ramWE = 0;
  113.                         _loadPC = 1;
  114.                         _PCinstr = 0;
  115.                         _instrEN = 0;
  116.                         _F = 0;
  117.                         _k = instrReg[9:3];
  118.                         _address1 = 0;
  119.                         _address2 = 0;
  120.                     end
  121.                     3'b001:
  122.                     if (Z_decode == 1) begin
  123.                         _S = 0;
  124.                         _ramWE = 0;
  125.                         _loadPC = 1;
  126.                         _PCinstr = 0;
  127.                         _instrEN = 0;
  128.                         _F = 0;
  129.                         _k = instrReg[9:3];
  130.                         _address1 = 0;
  131.                         _address2 = 0;
  132.                     end
  133.                     default: begin
  134.                         _S = 0;
  135.                         _ramWE = 0;
  136.                         _loadPC = 0;
  137.                         _PCinstr = 0;
  138.                         _instrEN = 0;
  139.                         _F = 0;
  140.                         _k = 0;
  141.                         _address1 = 0;
  142.                         _address2 = 0;
  143.                     end
  144.                 endcase
  145.             end
  146.             // CPI
  147.             16'b0110_????_????_????: begin
  148.                 _S = 0;  // Dejar pasar K
  149.                 _ramWE = 0;  // Deshabilitar escritura en RAM
  150.                 _loadPC = 0;
  151.                 _PCinstr = 0;
  152.                 _instrEN = 1;
  153.                 _F = 3'b011;  // Resta
  154.                 _k = 0;
  155.                 _address1 = {4'b0001, instrReg[7:4]};
  156.                 _address2 = 0;
  157.             end
  158.             // JMP
  159.             16'b0111_0000_0???_????: begin
  160.                 _S = 0;
  161.                 _ramWE = 0;
  162.                 _loadPC = 1;
  163.                 _PCinstr = 1;
  164.                 _instrEN = 0;
  165.                 _F = 0;
  166.                 _k = instrReg[6:0];
  167.                 _address1 = 0;
  168.                 _address2 = 0;
  169.             end
  170.             // IN
  171.             16'b1000_0???_????_????: begin
  172.                 _S = 1;  // Dejar pasar RrK
  173.                 _ramWE = 1;
  174.                 _loadPC = 0;
  175.                 _PCinstr = 0;
  176.                 _instrEN = 1;
  177.                 _F = _pasaRrk;
  178.                 _k = instrReg[6:0];
  179.                 _address1 = {3'b000, instrReg[8:4]};
  180.                 _address2 = {2'b00, instrReg[10:9], instrReg[3:0]} + 8'h20;
  181.             end
  182.             // LDI
  183.             16'b1001_????_????_????: begin
  184.                 _S = 0;  // Dejar pasar K
  185.                 _ramWE = 1;  // Habilitar escritura en RAM
  186.                 _loadPC = 0;
  187.                 _PCinstr = 0;
  188.                 _instrEN = 1;
  189.                 _F = 3'b000;  // Dejar pasar RrK
  190.                 _k = 0;
  191.                 _address1 = {4'b0001, instrReg[7:4]};
  192.                 _address2 = 0;
  193.             end
  194.             // LDS
  195.             16'b1010_????_????_????: begin
  196.                 _S = 1;  // Dejar pasar Rr
  197.                 _ramWE = 1;  // Habilitar escritura en RAM
  198.                 _loadPC = 0;
  199.                 _PCinstr = 0;
  200.                 _instrEN = 1;
  201.                 _F = 3'b000;  // Dejar pasar RrK
  202.                 _k = 0;
  203.                 _address1 = {instrReg[11:8], instrReg[3:0]};
  204.                 _address2 = {4'b0000, instrReg[7:4]};
  205.             end
  206.             // MOV
  207.             16'b1011_00??_????_????: begin
  208.                 _S = 1;  // Dejar pasar RrK
  209.                 _ramWE = 1;  // Habilitar escritura en RAM
  210.                 _loadPC = 0;
  211.                 _PCinstr = 0;
  212.                 _instrEN = 1;
  213.                 _F = 3'b000;  // Dejar pasar RrK
  214.                 _k = 0;
  215.                 _address1 = {3'b000, instrReg[8:4]};
  216.                 _address2 = {3'b000, instrReg[9], instrReg[3:0]};
  217.             end
  218.             // OUT
  219.             16'b1100_0???_????_????: begin
  220.                 _S = 1;  // Dejar pasar Rr
  221.                 _ramWE = 1;  // Habilitar escritura en RAM
  222.                 _loadPC = 0;
  223.                 _PCinstr = 0;
  224.                 _instrEN = 1;
  225.                 _F = 3'b000;  // Dejar pasar RrK
  226.                 _k = 0;
  227.                 _address1 = {2'b00, instrReg[10:9], instrReg[3:0]} + 8'h20;
  228.                 _address2 = {3'b000, instrReg[8:4]};
  229.             end
  230.             // STS
  231.             16'b1101_????_????_????: begin
  232.                 _S = 1;  // Dejar pasar Rr
  233.                 _ramWE = 1;  // Habilitar escritura en RAM
  234.                 _loadPC = 0;
  235.                 _PCinstr = 0;
  236.                 _instrEN = 1;
  237.                 _F = 3'b000;  // Dejar pasar RrK
  238.                 _k = 0;
  239.                 _address1 = {instrReg[11:8], instrReg[3:0]};
  240.                 _address2 = {4'b0000, instrReg[7:4]};
  241.             end
  242.             // CBI (pendiente)
  243.             16'b1110_????_????_????: begin
  244.                 _S = 1;  // Dejar pasar Rr
  245.                 _ramWE = 1;  // Habilitar escritura en RAM
  246.                 _loadPC = 0;
  247.                 _PCinstr = 0;
  248.                 _instrEN = 1;
  249.                 _F = 3'b000;  // Dejar pasar RrK
  250.                 _k = 0;
  251.                 _address1 = {instrReg[11:8], instrReg[3:0]};
  252.                 _address2 = {4'b0000, instrReg[7:4]};
  253.             end
  254.             // SBI (pendiente)
  255.             16'b1111_????_????_????: begin
  256.                 _S = 1;  // Dejar pasar Rr
  257.                 _ramWE = 1;  // Habilitar escritura en RAM
  258.                 _loadPC = 0;
  259.                 _PCinstr = 0;
  260.                 _instrEN = 1;
  261.                 _F = 3'b000;  // Dejar pasar RrK
  262.                 _k = 0;
  263.                 _address1 = {instrReg[11:8], instrReg[3:0]};
  264.                 _address2 = {4'b0000, instrReg[7:4]};
  265.             end
  266.             default: begin
  267.                 _S = 0;
  268.                 _ramWE = 0;
  269.                 _loadPC = 0;
  270.                 _PCinstr = 0;
  271.                 _instrEN = 0;
  272.                 _F = 0;
  273.                 _k = 0;
  274.                 _address1 = 0;
  275.                 _address2 = 0;
  276.             end
  277.  
  278.         endcase
  279.     end
  280.  
  281.     assign S = _S;
  282.     assign PCinstr = _PCinstr;
  283.     assign ramWE = _ramWE;
  284.     assign loadPC = _loadPC;
  285.     assign F = _F;
  286.     assign address1 = _address1;
  287.     assign address2 = _address2;
  288.     assign k = _k;
  289.     assign instrEN = _instrEN;
  290. endmodule
  291.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement