diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2021/2021-06-09/Verilog/sintesi.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2021/2021-06-09/Verilog/sintesi.v new file mode 100644 index 00000000..2383d709 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2021/2021-06-09/Verilog/sintesi.v @@ -0,0 +1,279 @@ +module ABC( + addr, data, ior_, iow_, + clock, reset_ +); + inout [7:0] data; + output [15:0] addr; + output ior_, iow_; + input clock, reset_; + + ParteOperativa PO( + addr, data, ior_, iow_, + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 + ); + + ParteControllo PC( + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 + ); + +endmodule + +module ParteOperativa( + addr, data, ior_, iow_, + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 +); + inout [7:0] data; + output [15:0] addr; + output ior_, iow_; + input clock, reset_; + + output c1, c0; + input b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0; + + reg IOW_, IOR_; + assign ior_ = IOR_; + assign iow_ = IOW_; + + reg [15:0] ADDR; + assign addr = ADDR; + + reg DIR; + reg [7:0] DATA; + assign data = (DIR == 1) ? DATA : 8'bZZ; + + reg [3:0] COUNT; + + reg [7:0] A, B; + wire [15:0] mul; + assign #1 mul = A * B; + + assign c0 = data[0]; + assign c1 = (COUNT == 4'b0000); + + always @(reset_ == 0) #1 begin + IOR_ <= 1; + IOW_ <= 1; + DIR <= 0; + A <= 0; + COUNT <= 15; + end + + /* + 6 registri operativi + + u-operazioni su ADDR + S1,S2,S4,S5,S6,S7,S8,S10: ADDR<=ADDR + S0: ADDR <= 16'h0120; + S3: ADDR <= 16'h0140; + S9: ADDR <= 16'h0100; + S11: ADDR <= 16'h0101; + + 3 variabili di comando (b2,b1,b0) + + + u-operazioni su COUNT + S0 fino a S13: COUNT <= COUNT - 1; + S14: COUNT <= (COUNT == 0) ? 15 : COUNT - 1; + + 1 variabile di comando (b3) + + u-operazioni su IOR_ + tutti gli altri stati: IOR_<=IOR_ + S1,S10,S12: IOR_<=0 + S2,S11,S14: IOR_<=1 + + 2 variabili di comando (b5,b4) + + + u-operazioni su IOW_ + tutti gli altri stati: IOW_<=IOW_ + S4,S7: IOW_<=0 + S5,S8: IOW_<=1 + + 2 variabili di comando (b7,b6) + + + u-operazioni su B + tutti gli altri stati: B<=B + S2: B <= data; + + 1 variabile di comando (b8) + + b0 + u-operazioni su DATA + tutti gli altri stati: DATA<=DATA + S3: DATA <= mul[15:8]; + S6: DATA <= mul[7:0]; + + 2 variabili di comando (b10,b9) + + + u-operazioni su A + tutti gli altri stati: A<=A + S13: A <= data; + + 1 variabile di comando (b11) + + u-operazioni su DIR + tutti gli altri stati: DIR<=DIR + S3: DIR<=1 + S9: DIR<=0 + + 2 variabili di comando (b13,b12) + */ + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b2,b1,b0}) + 3'b000: ADDR <= ADDR; + 3'b001: ADDR <= 16'h0120; + 3'b010: ADDR <= 16'h0140; + 3'b011: ADDR <= 16'h0100; + 3'b1XX: ADDR <= 16'h0101; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (b3) + 1'b0: COUNT <= COUNT - 1; + 1'b1: COUNT <= (COUNT == 0) ? 15 : COUNT - 1; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b5,b4}) + 2'b00: IOR_ <= IOR_; + 2'b01: IOR_ <= 0; + 2'b1X: IOR_ <= 1; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b7,b6}) + 2'b00: IOW_ <= IOW_; + 2'b01: IOW_ <= 0; + 2'b1X: IOW_ <= 1; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (b8) + 1'b0: B <= B; + 1'b1: B <= data; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b10,b9}) + 2'b00: DATA <= DATA; + 2'b01: DATA <= mul[15:8]; + 2'b1X: DATA <= mul[7:0]; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (b11) + 1'b0: A <= A; + 1'b1: A <= data; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b13,b12}) + 2'b00: DIR <= DIR; + 2'b01: DIR <= 1; + 2'b1X: DIR <= 0; + endcase + end + +endmodule + +module ParteControllo( + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 +); + input clock, reset_; + + input c1, c0; + output b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0; + + reg [3:0] STAR; + + localparam + S0 = 0, + S1 = 1, + S2 = 2, + S3 = 3, + S4 = 4, + S5 = 5, + S6 = 6, + S7 = 7, + S8 = 8, + S9 = 9, + S10 = 10, + S11 = 11, + S12 = 12, + S13 = 13, + S14 = 14; + + assign {b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0}= + (STAR==S0)? 14'b00000000000001: + (STAR==S1)? 14'b00000000010000: + (STAR==S2)? 14'b000001001X0000: + (STAR==S3)? 14'b01001000000010: + (STAR==S4)? 14'b00000001000000: + (STAR==S5)? 14'b0000001X000000: + (STAR==S6)? 14'b0001X000000000: + (STAR==S7)? 14'b00000001000000: + (STAR==S8)? 14'b0000001X000000: + (STAR==S9)? 14'b1X000000000011: + (STAR==S10)? 14'b00000000010000: + (STAR==S11)? 14'b000000001X01XX: + (STAR==S12)? 14'b00000000010000: + (STAR==S13)? 14'b00100000000000: + (STAR==S14)? 14'b000000001X1000: + /*default*/ 14'b00XXXXXXXXXXXX; + + always @(reset_ == 0) #1 STAR <= S0; + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (STAR) + S0: STAR <= S1; + + S1: STAR <= S2; + + S2: STAR <= S3; + + S3: STAR <= S4; + + S4: STAR <= S5; + + S5: STAR <= S6; + + S6: STAR <= S7; + + S7: STAR <= S8; + + S8: STAR <= S9; + + S9: STAR <= S10; + + S10: STAR <= S11; + + S11: STAR <= (c0==1) ? S12 : S14; + + S12: STAR <= S13; + + S13: STAR <= S14; + + S14: STAR <= (c1==1) ? S0 : S14; + endcase + end + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/esempio.txt b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/esempio.txt new file mode 100644 index 00000000..89af6edc --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/esempio.txt @@ -0,0 +1,18 @@ +6A50 +b4 +colpito! +c4 +colpito! +c4 +mancato! +d3 +colpito! +b3 +colpito! +c1 +mancato! +a2 +colpito! +c2 +colpito! +vittoria! diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/soluzione.s b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/soluzione.s new file mode 100644 index 00000000..dc9ccdd7 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/soluzione.s @@ -0,0 +1,74 @@ +.INCLUDE "./files/utility.s" + +.DATA +msg_colpito: .ASCII "colpito!\r" +msg_mancato: .ASCII "mancato!\r" +msg_vittoria: .ASCII "vittoria!\r" + +.TEXT + +_main: + NOP + + CALL inword + CALL newline + MOV %AX, %DX # in dx terremo le posizioni delle navi rimaste + +ciclo_partita: + CMP $0, %DX + JE vittoria + + CALL in_lettera + MOV %AL, %CL + SHL $2, %CL # cl = cl * 4, ossia la dimensione di ogni riga + CALL in_numero + ADD %AL, %CL # cl contiene l'indice (da 0 a 15) della posizione bersagliata + CALL newline + + MOV $1, %AX + SHL %CL, %AX # ax contiene una maschera da 16 bit con 1 nella posizione bersagliata + AND %DX, %AX # se abbiamo colpito qualcosa, ax rimane invariato. altrimenti varra' 0 + JZ mancato + +colpito: + LEA msg_colpito, %EBX + CALL outline + XOR %AX, %DX # togliamo il bersaglio colpito + JMP ciclo_partita_fine + +mancato: + LEA msg_mancato, %EBX + CALL outline + +ciclo_partita_fine: + JMP ciclo_partita + +vittoria: + LEA msg_vittoria, %EBX + CALL outline +fine: + RET + +# Sottoprogramma per la lettura della lettera, da 'a' a 'd' +# Lascia l'indice corrispondente (da 0 a 3) in AL +in_lettera: + CALL inchar + CMP $'a', %AL + JB in_lettera + CMP $'d', %AL + JA in_lettera + CALL outchar + SUB $'a', %AL + RET + +# Sottoprogramma per la lettura del numero, da '1' a '4' +# Lascia l'indice corrispondente (da 0 a 3) in AL +in_numero: + CALL inchar + CMP $'1', %AL + JB in_numero + CMP $'4', %AL + JA in_numero + CALL outchar + SUB $'1', %AL + RET diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/testo.pdf new file mode 100644 index 00000000..c937e6d3 Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Assembly/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/reti_standard.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/reti_standard.v new file mode 100644 index 00000000..39c095f2 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/reti_standard.v @@ -0,0 +1,58 @@ +// Sommatore valido sia per naturali che per interi, in base 2. +// Sia input che output sono a N cifre. +// Il circuito ha in uscita sia il carry che l'overflow, sta all'utilizzatore collegare quello corretto. +module add( + x, y, c_in, + s, c_out, ow +); + parameter N = 2; + + input [N-1:0] x, y; + input c_in; + + output [N-1:0] s; + output c_out, ow; + + assign #1 {c_out, s} = x + y + c_in; + assign #1 ow = (x[N-1] == y[N-1]) && (x[N-1] != s[N-1]); + +endmodule + +// Moltiplicatore con addizionatore per naturali in base 2. +// Moltiplicando (x) e addendo (c) a N bit, moltiplicatore (y) a M bit. +// Risultato (m) su N+M bit +module mul_add_nat( + x, y, c, + m +); + + parameter N = 2; + parameter M = 2; + + input [N-1:0] x, c; + input [M-1:0] y; + + output [N+M-1:0] m; + + assign #1 m = (x * y) + c; + +endmodule + +// Comparatore per naturali in base 2. +// Ingressi a N bit. +// Il flag min vale 1 se a < b +// Il flag eq vale 1 se a == b +module comp_nat( + a, b, + min, eq +); + + parameter N = 2; + + input [N-1:0] a, b; + output min, eq; + + assign min = (a < b); + assign eq = (a == b); + +endmodule diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/soluzione.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/soluzione.v new file mode 100644 index 00000000..f0af6685 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/soluzione.v @@ -0,0 +1,125 @@ +module ABC ( + soc_x, eoc_x, x, soc_y, eoc_y, y, + dav_, rfd, z, + clock, reset_ +); + input clock, reset_; + input eoc_x, eoc_y, rfd; + output soc_x, soc_y, dav_; + input [7:0] x, y; + output z; + + reg SOC, DAV_; + reg Z; + reg [2:0] STAR; + + localparam S0=0, S1=1, S2=2, S3=3; + + assign soc_x = SOC; + assign soc_y = SOC; + assign dav_ = DAV_; + assign z = Z; + + wire result; + IN_AREA m ( + .x(x), .y(y), .z(result) + ); + + always @(reset_==0) #1 + begin + SOC = 0; + DAV_ = 1; + STAR = S0; + end + + always @(posedge clock) if (reset_==1) #3 + casex(STAR) + S0: + begin + SOC <= 1; + STAR <= ({eoc_x, eoc_y} == 2'B00) ? S1 : S0; + end + S1: + begin + SOC <= 0; + Z <= result; + STAR <= ({eoc_x, eoc_y} == 2'B11) ? S2 : S1; + end + S2: + begin + DAV_ <= 0; + STAR <= (rfd == 1) ? S2 : S3; + end + S3: + begin + DAV_ <= 1; + STAR <= (rfd == 0) ? S3 : S0; + end + endcase + +endmodule + +// L'uscita z vale 1 se il punto è interno all'area del cerchio +module IN_AREA( + x, y, + z +); + input [7:0] x, y; + output z; + + localparam RAGGIO_QUADRO = 16'd4096; + + wire [7:0] abs_x, abs_y; + abs #( .N(8) ) a1 ( + .x(x), .abs_x(abs_x) + ); + abs #( .N(8) ) a2 ( + .x(y), .abs_x(abs_y) + ); + + wire [15:0] x_quadro; + mul_add_nat #( .N(8), .M(8) ) mx( + .x(abs_x), .y(abs_x), .c(8'd0), + .m(x_quadro) + ); + + wire [15:0] y_quadro; + mul_add_nat #( .N(8), .M(8) ) my( + .x(abs_y), .y(abs_y), .c(8'd0), + .m(y_quadro) + ); + + wire [15:0] somma; + add #( .N(16) ) somma_quadrati( + .x(x_quadro), .y(y_quadro), .c_in(1'B0), + .s(somma[15:0]) + ); + + comp_nat #( .N(16) ) comp( + .a(somma), .b(RAGGIO_QUADRO), + .min(in), .eq(bordo) + ); + + assign z = in | bordo; +endmodule + +// Valore assoluto di un numero intero +// L'ingresso x e' un numero intero su N bit +// L'uscita abs_x e' un numero naturale su N bit +module abs( + x, + abs_x +); + parameter N = 8; + + input [N-1:0] x; + output [N-1:0] abs_x; + + wire [N-1:0] neg_x; + add #( .N(N) ) a_neg_x( + .x(~x), .y(8'B0), .c_in(1'B1), + .s(neg_x) + ); + + assign abs_x = (x[N-1] == 1) ? neg_x : x; +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/testbench.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/testbench.v new file mode 100644 index 00000000..433dbfb3 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/testbench.v @@ -0,0 +1,180 @@ +module testbench(); + + wire clock; + + clock_generator clk( + .clock(clock) + ); + + reg reset_; + + wire soc_x, soc_y; + reg eoc_x, eoc_y; + reg [7:0] x, y; + + wire dav_; + reg rfd; + wire z; + + ABC dut ( + .soc_x(soc_x), .soc_y(soc_y), .eoc_x(eoc_x), .x(x), .eoc_y(eoc_y), .y(y), + .dav_(dav_), .rfd(rfd), .z(z), + .clock(clock), .reset_(reset_) + ); + + initial + begin + $dumpfile("waveform.vcd"); + $dumpvars; + + //the following structure is used to wait for expected signals, and fail if too much time passes + fork : f + begin + #100000; + $display("Timeout - waiting for signal failed"); + disable f; + end + //actual tests start here + begin + eoc_x = 1; eoc_y = 1; + rfd = 1; + + //reset phase + reset_ = 0; #(clk.HALF_PERIOD); + + //first posedge + reset_ = 1; + + if(soc_x !== 0) + $display("soc_x is not 0 after reset"); + + if(soc_y !== 0) + $display("soc_y is not 0 after reset"); + + if(dav_ !== 1) + $display("dav_ is not 1 after reset"); + + fork + //Produttore X + begin : producer_x + reg [5:0] i; + reg [7:0] t_x, t_y; + reg t_z; + + for (i = 0; i < 32; i++) begin + {t_x, t_y, t_z} = get_testcase(i[4:0]); + + @(posedge soc_x); + #(1*2*clk.HALF_PERIOD); + eoc_x = 0; + @(negedge soc_x); + #(1*2*clk.HALF_PERIOD); + x = t_x; + #(1*2*clk.HALF_PERIOD); + eoc_x = 1; + end + end + + //Produttore Y + begin : producer_y + reg [5:0] i; + reg [7:0] t_x, t_y; + reg t_z; + + for (i = 0; i < 32; i++) begin + {t_x, t_y, t_z} = get_testcase(i[4:0]); + + @(posedge soc_y); + #(2*2*clk.HALF_PERIOD); + eoc_y = 0; + @(negedge soc_y); + #(2*2*clk.HALF_PERIOD); + y = t_y; + #(2*2*clk.HALF_PERIOD); + eoc_y = 1; + end + end + + //Consumer + begin : consumer + reg [5:0] i; + reg [7:0] t_x, t_y; + reg t_z; + + for (i = 0; i < 32; i++) begin + {t_x, t_y, t_z} = get_testcase(i[4:0]); + + @(negedge dav_); + if(z !== t_z) + $display("Test #%g failed, expected %g, got %g", i, t_z, z); + #(2*clk.HALF_PERIOD); rfd = 0; + @(posedge dav_); + #(2*clk.HALF_PERIOD); rfd = 1; + end + end + join + + disable f; + end + join + + $finish; + end + + function automatic [23:0] get_testcase; + input [4:0] i; + + reg [7:0] x, y; + reg z; + reg [4:0] j; + + begin + if(i[2:0] == 3'd0) begin + // valori limite da testare singolarmente + casex(i[4:3]) + 2'd0: {x, y, z} = {8'd0, 8'd0, 1'b1}; + 2'd1: {x, y, z} = {-8'd128, 8'd0, 1'b0}; + 2'd2: {x, y, z} = {8'd0, -8'd128, 1'b0}; + 2'd3: {x, y, z} = {-8'd128, -8'd128, 1'b0}; + endcase + end + else begin + // valori da testare in tutti i quadranti + casex(i[2:0]) + 3'd1: {x, y, z} = {8'd40, 8'd40, 1'b1}; + 3'd2: {x, y, z} = {8'd30, 8'd50, 1'b1}; + 3'd3: {x, y, z} = {8'd50, 8'd30, 1'b1}; + 3'd4: {x, y, z} = {8'd50, 8'd40, 1'b0}; + 3'd5: {x, y, z} = {8'd50, 8'd50, 1'b0}; + 3'd6: {x, y, z} = {8'd64, 8'd0, 1'b1}; + 3'd7: {x, y, z} = {8'd0, 8'd64, 1'b1}; + endcase + + casex(i[4:3]) + 2'd0: {x, y, z} = {x, y, z}; + 2'd1: {x, y, z} = {-x, y, z}; + 2'd2: {x, y, z} = {x, -y, z}; + 2'd3: {x, y, z} = {-x, -y, z}; + endcase + end + + get_testcase = {x, y, z}; + end + endfunction +endmodule + +// generatore del segnale di clock +module clock_generator( + clock +); + output clock; + + parameter HALF_PERIOD = 5; + + reg CLOCK; + assign clock = CLOCK; + + initial CLOCK <= 0; + always #HALF_PERIOD CLOCK <= ~CLOCK; + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/testo.pdf new file mode 100644 index 00000000..637d5ba1 Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-06/Verilog/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/esempio.txt b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/esempio.txt new file mode 100644 index 00000000..2467ae38 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/esempio.txt @@ -0,0 +1,8 @@ +1118880967 +1188809671 +1888096711 +8880967111 +1888096711 +8880967111 +6711188809 +7111888096 diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/soluzione.s b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/soluzione.s new file mode 100644 index 00000000..b8c7d219 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/soluzione.s @@ -0,0 +1,89 @@ +.include "./files/utility.s" + +.data +buffer: .fill 10, 1 + +.text +_main: + nop + +#punto 1 + mov $10, %ecx + lea buffer, %ebx +ingresso: + call indigit + call outchar + mov %al, (%ebx) + inc %ebx + loop ingresso + call newline + + lea buffer, %ebx #ebx punta al primo elemento del buffer + mov $0, %esi #esi contiene l'indice del primo elemento da stampare + +comandi: + call inchar + cmp $'q', %al + je sinistra + cmp $'w', %al + je destra + cmp $'e', %al + je swap + cmp $'z', %al + je fine + jmp comandi + +sinistra: + cmp $9, %esi + je reset_s + inc %esi + jmp stampa +reset_s: + mov $0, %esi + jmp stampa + +destra: + cmp $0, %esi + je reset_d + dec %esi + jmp stampa +reset_d: + mov $9, %esi + jmp stampa + +swap: + add $5, %esi + cmp $10, %esi + jae reset_swap + jmp stampa +reset_swap: + sub $10, %esi + jmp stampa + +stampa: + mov %esi, %edi + mov $10, %ecx +scrivi: + mov (%ebx, %edi), %al + call outchar + cmp $9, %edi + je resetp + inc %edi + jmp chiudi +resetp: + mov $0, %edi +chiudi: + loop scrivi + call newline + jmp comandi + +fine: + ret + +indigit: + call inchar + cmp $'0', %al + jb indigit + cmp $'9', %al + ja indigit + ret diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/testo.pdf new file mode 100644 index 00000000..36819100 Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Assembly/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/reti_standard.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/reti_standard.v new file mode 100644 index 00000000..b5f644a9 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/reti_standard.v @@ -0,0 +1,19 @@ +// Sommatore valido sia per naturali che per interi, in base 2. +// Sia input che output sono a N cifre. +// Il circuito ha in uscita sia il carry che l'overflow, sta all'utilizzatore collegare quello corretto. +module add( + x, y, c_in, + s, c_out, ow +); + parameter N = 2; + + input [N-1:0] x, y; + input c_in; + + output [N-1:0] s; + output c_out, ow; + + assign #1 {c_out, s} = x + y + c_in; + assign #1 ow = (x[N-1] == y[N-1]) && (x[N-1] != s[N-1]); + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/soluzione.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/soluzione.v new file mode 100644 index 00000000..ca202c1a --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/soluzione.v @@ -0,0 +1,76 @@ +module ABC ( + rfd_x, dav_x, x, rfd_y, dav_y, y, + out, + clock, reset_ +); + input clock, reset_; + input dav_x, dav_y; + output rfd_x, rfd_y; + input [7:0] x, y; + output out; + + reg RFD; + reg OUT; + reg [2:0] STAR; + reg [7:0] COUNT; + + localparam S0=0, S1=1, S2=2, S3=3; + + assign rfd_x = RFD; + assign rfd_y = RFD; + assign out = OUT; + + wire [7:0] max; + MAX m ( + .x(x), .y(y), .max(max) + ); + + always @(reset_==0) #1 + begin + RFD = 1; + OUT = 0; + STAR = S0; + end + + always @(posedge clock) if (reset_==1) #3 + casex(STAR) + S0: + begin + RFD <= 1; + OUT <= 0; + COUNT <= max; + STAR <= ({dav_x, dav_y} == 2'B00) ? S1 : S0; + end + S1: + begin + RFD <= 0; + STAR <= ({dav_x, dav_y} == 2'B11) ? S2 : S1; + end + S2: + begin + OUT <= 1; + COUNT <= COUNT - 1; + STAR <= (COUNT == 1) ? S0 : S2; + end + endcase + +endmodule + +module MAX( + x, y, + max +); + input [7:0] x, y; + output [7:0] max; + + wire [7:0] y_neg = y[7] ? y : (~y + 1); + wire c_out; + add #( .N(8) ) s ( + .x(x), .y(y_neg), .c_in(1'b1), + .c_out(c_out) + ); + + wire b_out = ~c_out; + + assign max = b_out ? y : x; +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/testbench.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/testbench.v new file mode 100644 index 00000000..dad0ce47 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/testbench.v @@ -0,0 +1,166 @@ +module testbench(); + + wire clock; + + clock_generator clk( + .clock(clock) + ); + + reg reset_; + + wire rfd_x, rfd_y; + reg dav_x, dav_y; + reg [7:0] x, y; + + wire out; + + ABC dut ( + .rfd_x(rfd_x), .rfd_y(rfd_y), .dav_x(dav_x), .x(x), .dav_y(dav_y), .y(y), + .out(out), + .clock(clock), .reset_(reset_) + ); + + initial + begin + $dumpfile("waveform.vcd"); + $dumpvars; + + //the following structure is used to wait for expected signals, and fail if too much time passes + fork : f + begin + #100000; + $display("Timeout - waiting for signal failed"); + disable f; + end + //actual tests start here + begin + dav_x = 1; dav_y = 1; + + //reset phase + reset_ = 0; #(clk.HALF_PERIOD); + + //first posedge + reset_ = 1; + + if(rfd_x !== 1) + $display("rfd_x is not 1 after reset"); + + if(rfd_y !== 1) + $display("rfd_y is not 1 after reset"); + + if(out !== 0) + $display("out is not 0 after reset"); + + fork + //Produttore X + begin : producer_x + reg [5:0] i; + reg [7:0] t_x, t_y, t_z; + + for (i = 0; i < 32; i++) begin + {t_x, t_y, t_z} = get_testcase(i[4:0]); + + #(3*2*clk.HALF_PERIOD); + x = t_x; + #(1*2*clk.HALF_PERIOD); + dav_x = 0; + @(negedge rfd_x); + #(3*2*clk.HALF_PERIOD); + dav_x = 1; + x = 8'hXX; + @(posedge rfd_x); + end + end + + //Produttore Y + begin : producer_y + reg [5:0] i; + reg [7:0] t_x, t_y, t_z; + + for (i = 0; i < 32; i++) begin + {t_x, t_y, t_z} = get_testcase(i[4:0]); + + #(2*3*2*clk.HALF_PERIOD); + y = t_y; + #(2*1*2*clk.HALF_PERIOD); + dav_y = 0; + @(negedge rfd_y); + #(2*3*2*clk.HALF_PERIOD); + dav_y = 1; + y = 8'hXX; + @(posedge rfd_y); + end + end + + //Consumer + begin : consumer + reg [5:0] i; + reg [7:0] t_x, t_y, t_z; + + realtime sample_pe; + realtime sample_ne; + realtime diff; + + for (i = 0; i < 32; i++) begin + {t_x, t_y, t_z} = get_testcase(i[4:0]); + + @(posedge out); + sample_pe = $realtime; + @(negedge out); + sample_ne = $realtime; + + diff = (sample_ne - sample_pe)/(2*clk.HALF_PERIOD); + + if(diff != t_z) + $display("Test #%g failed, expected %g, got %g", i, t_z, diff); + end + end + join + + disable f; + end + join + + $finish; + end + + function automatic [23:0] get_testcase; + input [4:0] i; + + reg [7:0] x, y, z; + + begin + if( i[0] == 1) begin + x = (i[4:2] + 4) * 3; + y = (i[1:0] + 1) * 5; + end + else begin + x = (i[1:0] + 1) * 5; + y = (i[4:2] + 4) * 3; + end + + x = x > 0 ? x : 1; + y = y > 0 ? y : 1; + + z = x > y ? x : y; + + get_testcase = {x, y, z}; + end + endfunction +endmodule + +// generatore del segnale di clock +module clock_generator( + clock +); + output clock; + + parameter HALF_PERIOD = 5; + + reg CLOCK; + assign clock = CLOCK; + + initial CLOCK <= 0; + always #HALF_PERIOD CLOCK <= ~CLOCK; + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/testo.pdf new file mode 100644 index 00000000..4722fdcb Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-06-27/Verilog/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/esempio.txt b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/esempio.txt new file mode 100644 index 00000000..2d78e3b1 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/esempio.txt @@ -0,0 +1,8 @@ +000010 +7 + +105261 +18663 + +000000 +0 diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/soluzione.s b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/soluzione.s new file mode 100644 index 00000000..5e085b7f --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/soluzione.s @@ -0,0 +1,44 @@ +.include "./files/utility.s" + +.text +_main: + nop + +punto1: + mov $0, %ebx + + mov $6, %ecx +ingresso: + mov $0, %eax + call indigit + xchg %eax, %ebx + mov $7, %dx + mul %dx + shl $16, %edx + mov %ax, %dx + add %edx, %ebx + loop ingresso + +stampa: + mov %ebx, %eax + call newline + call outdecimal_long + call newline + + cmp $0, %eax + je fine + call newline + jmp punto1 + +fine: + ret + +indigit: + call inchar + cmp $'0', %al + jb indigit + cmp $'6', %al + ja indigit + call outchar + sub $'0', %al + ret diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/testo.pdf new file mode 100644 index 00000000..8b6c06b0 Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Assembly/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/reti_standard.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/reti_standard.v new file mode 100644 index 00000000..b5f644a9 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/reti_standard.v @@ -0,0 +1,19 @@ +// Sommatore valido sia per naturali che per interi, in base 2. +// Sia input che output sono a N cifre. +// Il circuito ha in uscita sia il carry che l'overflow, sta all'utilizzatore collegare quello corretto. +module add( + x, y, c_in, + s, c_out, ow +); + parameter N = 2; + + input [N-1:0] x, y; + input c_in; + + output [N-1:0] s; + output c_out, ow; + + assign #1 {c_out, s} = x + y + c_in; + assign #1 ow = (x[N-1] == y[N-1]) && (x[N-1] != s[N-1]); + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/soluzione.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/soluzione.v new file mode 100644 index 00000000..badc6f33 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/soluzione.v @@ -0,0 +1,141 @@ +module ABC( + addr, data, ior_, iow_, + clock, reset_ +); + inout [7:0] data; + output [15:0] addr; + output ior_, iow_; + input clock, reset_; + + reg IOW_, IOR_; + assign ior_ = IOR_; + assign iow_ = IOW_; + + reg [15:0] ADDR; + assign addr = ADDR; + + reg DIR; + reg [7:0] DATA; + assign data = (DIR == 1) ? DATA : 8'bZZ; + + reg [3:0] STAR; + localparam + SA_0 = 0, + SA_1 = 1, + SA_2 = 2, + SA_3 = 3, + SA_4 = 4, + SA_5 = 5, + SB_0 = 6, + SB_1 = 7, + SB_2 = 8, + SB_3 = 9, + SB_4 = 10, + SB_5 = 11; + + reg [7:0] A; + wire [15:0] mul; + MUL5 m5 ( + .a(A), .m(mul) + ); + + always @(reset_ == 0) #1 begin + IOR_ <= 1; + IOW_ <= 1; + DIR <= 0; + A <= 0; + STAR <= SA_0; + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (STAR) + // Lettura da RSR di A + SA_0: begin + ADDR <= 16'h0100; + DIR <= 0; + STAR <= SA_1; + end + + SA_1: begin + IOR_ <= 0; + STAR <= SA_2; + end + + SA_2: begin + IOR_ <= 1; + STAR <= data[0] ? SA_3 : SA_0; // controllo FI + end + + // Lettura da RBR di A + SA_3: begin + ADDR <= 16'h0101; + STAR <= SA_4; + end + + SA_4: begin + IOR_ <= 0; + STAR <= SA_5; + end + + SA_5: begin + A <= data; + IOR_ <= 1; + STAR <= SB_0; + end + + // Scrittura in TBR di B + SB_0: begin + DATA <= mul[15:8]; + ADDR <= 16'h0121; + DIR <= 1; + STAR <= SB_1; + end + + SB_1: begin + IOW_ <= 0; + STAR <= SB_2; + end + + SB_2: begin + IOW_ <= 1; + STAR <= SB_3; + end + + SB_3: begin + DATA <= mul[7:0]; + STAR <= SB_4; + end + + SB_4: begin + IOW_ <= 0; + STAR <= SB_5; + end + + SB_5: begin + IOW_ <= 1; + STAR <= SA_0; + end + + endcase + end + +endmodule + +module MUL5(a, m); + input [7:0] a; + output [15:0] m; + + wire [9:0] a1_ext; + assign a1_ext = {2'b00, a}; + wire [9:0] a4_ext; + assign a4_ext = {a, 2'b00}; + + wire [9:0] sum; + wire c_out; + add #( .N(10) ) s ( + .x(a1_ext), .y(a4_ext), .c_in(1'b0), + .s(sum), .c_out(c_out) + ); + + assign m = { 5'h00, c_out, sum }; +endmodule diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/testbench.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/testbench.v new file mode 100644 index 00000000..3f3bb90d --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/testbench.v @@ -0,0 +1,313 @@ +module testbench(); + + wire clock; + reg reset_; + + clock_generator clk( + .clock(clock) + ); + + wire [15:0] addr; + wire [7:0] data; + wire ior_, iow_; + + ABC dut ( + .iow_(iow_), .ior_(ior_), .addr(addr), .data(data), + .reset_(reset_), .clock(clock) + ); + + // i fili del bus sono ritardati e ballanti cosicché le corse critiche vadano quasi sempre male :) + reg [15:0] addr_io; + reg s_A_, s_B_in_, s_B_out_; + always @(addr) begin + {s_A_, s_B_in_, s_B_out_, addr_io} = 'bX; + #1; + addr_io = addr; + #1; + s_A_ = ( { addr_io[15:1], 1'B0 } == 16'h0100 ) ? 0 : 1; + #1; + s_B_in_ = ( addr_io == 16'h0120 ) ? 0 : 1; + #1; + s_B_out_ = ( addr_io == 16'h0121 ) ? 0 : 1; + end + reg ior_io_, iow_io_; + always @(negedge ior_) ior_io_ = ior_; + always @(posedge ior_) #4 ior_io_ = ior_; + always @(negedge iow_) iow_io_ = iow_; + always @(posedge iow_) #4 iow_io_ = iow_; + + // testbench variables to control interfaces + reg tb_fiA; + reg [7:0] tb_valueA, tb_value_B_in; + wire tb_signal_read_A; + wire [7:0] tb_value_B_out; + wire tb_signal_write_B_out; + + interface_in_hs A( + .s_(s_A_), .ior_(ior_io_), .addr(addr_io[0]), .data(data), + .tb_value(tb_valueA), .tb_fi(tb_fiA), .tb_signal_read(tb_signal_read_A) + ); + + interface_in B_in( + .ior_(ior_io_), .s_(s_B_in_), .data(data), + .tb_value(tb_value_B_in) + ); + + interface_out B_out( + .iow_(iow_io_), .s_(s_B_out_), .data(data), + .tb_value(tb_value_B_out), .tb_signal_write(tb_signal_write_B_out) + ); + + wire io_CA_error; + wire s_catch_all_; + assign s_catch_all_ = ~(s_A_ === 1'b1 | s_A_ === 1'bX) | ~(s_B_in_ === 1'b1 | s_B_in_ === 1'bX) | ~(s_B_out_ === 1'b1 | s_B_out_ === 1'bX); + + io_catch_all io_CA( + .iow_(iow_io_), .ior_(ior_io_), .s_(s_catch_all_), + .tb_error(io_CA_error) + ); + + // Debug variables to highlight errors in waveform diagram + reg error_value; + reg error_timing; + + initial + begin + $dumpfile("waveform.vcd"); + $dumpvars; + + error_value = 0; + error_timing = 0; + + //the following structure is used to wait for expected signals, and fail if too much time passes + fork : f + begin + #100000; + $display("Timeout - waiting for signal failed"); + disable f; + end + //actual tests start here + begin + //reset phase + reset_ = 0; #(clk.HALF_PERIOD); + tb_value_B_in = 8'hDE; + + //first posedge + reset_ = 1; + + fork + begin : A + reg [7:0] i; + + for(i = 0; i < 30; i++) begin + tb_valueA = i + 3; + tb_fiA = 0; + #(12*2*clk.HALF_PERIOD); + tb_valueA = i * i + 5; + tb_fiA = 1; + + @(posedge tb_signal_read_A); + @(negedge tb_signal_read_A); + #1; + end + end + + begin : B_out + reg [7:0] i; + reg [7:0] curr_A; + reg [15:0] expected; + reg [15:0] current; + + expected = 0; + current = 0; + + for(i = 0; i < 30; i++) begin + // Punto 1 + curr_A = i * i + 5; + @(negedge s_B_out_); + + // Punto 2 + expected = curr_A * 5; + + @(posedge tb_signal_write_B_out); + current[15:8] = tb_value_B_out; + @(posedge tb_signal_write_B_out); + current[7:0] = tb_value_B_out; + + if(expected !== current) begin + $display("Wrong output: expected %d, got %d instead", expected, current); + error_value = 1; + end + end + end + join + + disable f; + end + join + + $finish; + end + + always @(posedge error_value) #1 + error_value = 0; + + always @(posedge error_timing) #1 + error_timing = 0; + +endmodule + +// il modulo interface simula una interfaccia di ingresso parallela con handshake +// gli ingressi tb_* sono utilizzati dalla testbench per guidare lo stato dell'interfaccia +module interface_in_hs ( + ior_, s_, addr, data, + tb_value, tb_fi, tb_signal_read +); + input ior_; + input s_; + input addr; + inout [7:0] data; + + input [7:0] tb_value; + input tb_fi; + output tb_signal_read; + + reg DIR; + + reg [7:0] DATA; + assign data = (DIR == 1) ? DATA : 8'hZZ; + + reg TB_SIGNAL_READ; + assign tb_signal_read = TB_SIGNAL_READ; + + always @(*) if (s_==1 || ior_==1) begin + DIR = 0; + TB_SIGNAL_READ = 0; + end + + always @(*) if (ior_==0 && s_==0) + begin + DIR = 1; + casex(addr) + 1'b0: begin + DATA = { 7'b0, tb_fi }; + TB_SIGNAL_READ = 0; + end + 1'b1: begin + DATA = tb_value; + if(tb_fi != 1) begin + $display("Read access while FI is 0!"); + TB_SIGNAL_READ = 0; + end + else begin + TB_SIGNAL_READ = 1; + end + end + endcase + end + +endmodule + +// il modulo simula una interfaccia di ingresso parallela senza handshake +// l'ingresso tb_value è utilizzato dalla testbench per guidare lo stato dell'interfaccia +module interface_in ( + ior_, s_, data, + tb_value +); + input ior_; + input s_; + output [7:0] data; + + input [7:0] tb_value; + + reg DIR; + + reg [7:0] DATA; + assign data = (DIR == 1) ? DATA : 8'hZZ; + + always @(*) if (s_==1 || ior_==1) + DIR = 0; + + always @(*) if (ior_==0 && s_==0) + begin + DIR = 1; + DATA = tb_value; + end + +endmodule + +// il modulo simula una interfaccia di uscita parallela senza handshake +// le uscite tb_* sono utilizzate dalla testbench per controllare lo stato dell'interfaccia +module interface_out ( + iow_, s_, data, + tb_value, tb_signal_write +); + input iow_; + input s_; + input [7:0] data; + + output [7:0] tb_value; + output tb_signal_write; + + reg [7:0] TB_VALUE; + assign tb_value = TB_VALUE; + + reg TB_SIGNAL_WRITE; + assign tb_signal_write = TB_SIGNAL_WRITE; + + always @(*) if (iow_==1 || s_==1) + begin + TB_SIGNAL_WRITE = 0; + end + + always @(*) if (iow_==0 && s_==0) + begin + TB_VALUE = data; + TB_SIGNAL_WRITE = 1; + end + +endmodule + +// il modulo io_catch_all simula tutto il resto dello spazio io: +// ogni comando che lo raggiunge e' un errore +module io_catch_all( + iow_, ior_, s_, + tb_error +); + input iow_, ior_, s_; + output tb_error; + + reg error; assign tb_error = error; + initial error = 0; + always @(posedge error) #1 + error = 0; + + always @(negedge iow_) #0.1 + if(s_ == 0) begin + error = 1; + $display("Invalid write access to random interface!"); + end + + always @(negedge ior_) #0.1 + if(s_ == 0) begin + error = 1; + $display("Invalid read access to random interface!"); + end + +endmodule + +// generatore del segnale di clock +module clock_generator( + clock +); + output clock; + + parameter HALF_PERIOD = 5; + + reg CLOCK; + assign clock = CLOCK; + + initial CLOCK <= 0; + always #HALF_PERIOD CLOCK <= ~CLOCK; + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/testo.pdf new file mode 100644 index 00000000..25db0712 Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-07-18/Verilog/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/esempio.txt b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/esempio.txt new file mode 100644 index 00000000..a251b0a2 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/esempio.txt @@ -0,0 +1,2 @@ +10 +2 3 5 7 11 13 17 19 23 29 diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/soluzione.s b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/soluzione.s new file mode 100644 index 00000000..85efc19c --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/soluzione.s @@ -0,0 +1,86 @@ +.include "./files/utility.s" + +.data +primi: .fill 100, 1, 0 # vettore contenente i primi trovati finora +count: .byte 0 # numero di primi trovati finora + +.text +_main: + nop + + # inizializzazione della lista con 2 e 3 + lea primi, %edi + movb $2, (%edi) + inc %edi + movb $3, (%edi) + movb $2, count + + call indecimal_byte # al contiene il numero di primi da trovare + call newline + +trova_n_primi: + cmpb %al, count + je stampa_primi + call find_next_prime + jmp trova_n_primi + +stampa_primi: + mov $0, %ecx +stampa_primi_loop: + cmpb %cl, count + je fine + movb primi(%ecx), %al + call outdecimal_byte + movb $' ', %al + call outchar + inc %ecx + jmp stampa_primi_loop + +fine: + call newline + ret + +find_next_prime: + push %eax + push %ebx + push %ecx + push %edx + + mov $0, %ecx + movb count, %cl + dec %cl + movb primi(%ecx), %bl # lettura dell'ultimo primo trovato + add $2, %bl # primo candidato primo + +test_candidato_primo: + mov $0, %ecx # indice del prossimo primo noto da usare per il test +test_primi_noti: + cmpb count, %cl + je candidato_primo_vero + + movb $0, %ah + movb %bl, %al + movb primi(%ecx), %dl + div %dl # ah conterra' il resto della divisione + + cmpb $0, %ah + je candidato_primo_falso + + inc %ecx + jmp test_primi_noti + +candidato_primo_falso: + add $2, %bl # prossimo candidato primo + jmp test_candidato_primo + +candidato_primo_vero: + mov $0, %ecx + movb count, %cl + movb %bl, primi(%ecx) # salva il primo trovato e incrementa count + incb count + + pop %edx + pop %ecx + pop %ebx + pop %eax + ret diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/testo.pdf new file mode 100644 index 00000000..27776f1f Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Assembly/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/reti_standard.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/reti_standard.v new file mode 100644 index 00000000..39c095f2 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/reti_standard.v @@ -0,0 +1,58 @@ +// Sommatore valido sia per naturali che per interi, in base 2. +// Sia input che output sono a N cifre. +// Il circuito ha in uscita sia il carry che l'overflow, sta all'utilizzatore collegare quello corretto. +module add( + x, y, c_in, + s, c_out, ow +); + parameter N = 2; + + input [N-1:0] x, y; + input c_in; + + output [N-1:0] s; + output c_out, ow; + + assign #1 {c_out, s} = x + y + c_in; + assign #1 ow = (x[N-1] == y[N-1]) && (x[N-1] != s[N-1]); + +endmodule + +// Moltiplicatore con addizionatore per naturali in base 2. +// Moltiplicando (x) e addendo (c) a N bit, moltiplicatore (y) a M bit. +// Risultato (m) su N+M bit +module mul_add_nat( + x, y, c, + m +); + + parameter N = 2; + parameter M = 2; + + input [N-1:0] x, c; + input [M-1:0] y; + + output [N+M-1:0] m; + + assign #1 m = (x * y) + c; + +endmodule + +// Comparatore per naturali in base 2. +// Ingressi a N bit. +// Il flag min vale 1 se a < b +// Il flag eq vale 1 se a == b +module comp_nat( + a, b, + min, eq +); + + parameter N = 2; + + input [N-1:0] a, b; + output min, eq; + + assign min = (a < b); + assign eq = (a == b); + +endmodule diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/soluzione.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/soluzione.v new file mode 100644 index 00000000..5fc80d36 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/soluzione.v @@ -0,0 +1,84 @@ +module ABC ( + x, y, + soc, eoc, out, + clock, reset_ +); + input clock, reset_; + input soc; + output eoc; + output [7:0] x; + input [7:0] y; + output [15:0] out; + + reg EOC; + reg [7:0] X; + reg [15:0] OUT; + + reg [2:0] STAR; + + localparam S0=0, S1=1, S2=2, S3=3; + + assign eoc = EOC; + assign x = X; + assign out = OUT; + + wire check; + CHECK c ( + .x(x), .y(y), .check(check) + ); + + always @(reset_==0) #1 + begin + EOC = 1; + X = 0; + OUT = 0; + STAR = S0; + end + + always @(posedge clock) if (reset_==1) #3 + casex(STAR) + S0: + begin + EOC <= 1; + STAR <= soc ? S1 : S0; + end + S1: + begin + EOC <= 0; + STAR <= soc ? S1 : S2; + end + S2: + begin + X <= X + 1; + STAR <= S3; + end + S3: + begin + OUT <= {X, y}; + STAR <= check ? S0 : S2; + end + endcase + +endmodule + +module CHECK( + x, y, + check +); + input [7:0] x, y; + output check; + + wire [15:0] prod; + mul_add_nat #( .N(8), .M(8) ) m ( + .x(x), .y(y), .c(8'b0), + .m(prod) + ); + + wire min; + comp_nat #( .N(16) ) comp ( + .a(prod), .b(16'hABBA), + .min(min) + ); + + assign check = ~min; +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/testbench.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/testbench.v new file mode 100644 index 00000000..8f7b2550 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/testbench.v @@ -0,0 +1,131 @@ +module testbench(); + + wire clock; + + clock_generator clk( + .clock(clock) + ); + + reg reset_; + + wire [7:0] x, y; + + wire eoc; + reg soc; + wire [15:0] out; + + ABC dut ( + .x(x), .y(y), + .soc(soc), .eoc(eoc), .out(out), + .clock(clock), .reset_(reset_) + ); + + A rc ( + .x(x), .y(y) + ); + + initial begin + $dumpfile("waveform.vcd"); + $dumpvars; + + //the following structure is used to wait for expected signals, and fail if too much time passes + fork : f + begin + #100000; + $display("Timeout - waiting for signal failed"); + disable f; + end + //actual tests start here + begin + soc = 0; + + //reset phase + reset_ = 0; #(clk.HALF_PERIOD); + + //first posedge + reset_ = 1; + + if(eoc !== 1) + $display("eoc is not 1 after reset"); + + fork + //B + begin : B + reg [5:0] i; + reg [7:0] t_x, t_y; + reg do_loop; + + t_x = 0; + for (i = 0; i < 32; i++) begin + do_loop = 1; + while (do_loop) begin + t_x += 1; + t_y = A_function(t_x); + if ((t_x * t_y) < 'hABBA) + do_loop = 1; + else + do_loop = 0; + end + + soc = 1; + @(negedge eoc); + #(3*2*clk.HALF_PERIOD); + soc = 0; + @(posedge eoc); + + if(out !== {t_x, t_y}) + $display("Test #%g failed, expected %g, got %g", i, {t_x, t_y}, out); + end + end + join + + disable f; + end + join + + $finish; + end + + function automatic [15:0] A_function; + input [7:0] x; + reg [7:0] y; + + begin + y = {x[1:0], x[5:4], x[7:6], x[3:2]}; + A_function = {x, y}; + end + endfunction +endmodule + +module A(x, y); + input [7:0] x; + output [7:0] y; + + assign #1 y = A_function(x); + + function automatic [15:0] A_function; + input [7:0] x; + reg [7:0] y; + + begin + y = {x[1:0], x[5:4], x[7:6], x[3:2]}; + A_function = {x, y}; + end + endfunction +endmodule + +// generatore del segnale di clock +module clock_generator( + clock +); + output clock; + + parameter HALF_PERIOD = 5; + + reg CLOCK; + assign clock = CLOCK; + + initial CLOCK <= 0; + always #HALF_PERIOD CLOCK <= ~CLOCK; + +endmodule \ No newline at end of file diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/testo.pdf b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/testo.pdf new file mode 100644 index 00000000..8fd86591 Binary files /dev/null and b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Esami/Scritti/2023/2023-09-12/Verilog/testo.pdf differ diff --git a/SECONDO ANNO/I SEMESTRE/Reti Logiche/Laboratori/Esercitazioni Verilog/8/sintesi.v b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Laboratori/Esercitazioni Verilog/8/sintesi.v new file mode 100644 index 00000000..2383d709 --- /dev/null +++ b/SECONDO ANNO/I SEMESTRE/Reti Logiche/Laboratori/Esercitazioni Verilog/8/sintesi.v @@ -0,0 +1,279 @@ +module ABC( + addr, data, ior_, iow_, + clock, reset_ +); + inout [7:0] data; + output [15:0] addr; + output ior_, iow_; + input clock, reset_; + + ParteOperativa PO( + addr, data, ior_, iow_, + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 + ); + + ParteControllo PC( + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 + ); + +endmodule + +module ParteOperativa( + addr, data, ior_, iow_, + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 +); + inout [7:0] data; + output [15:0] addr; + output ior_, iow_; + input clock, reset_; + + output c1, c0; + input b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0; + + reg IOW_, IOR_; + assign ior_ = IOR_; + assign iow_ = IOW_; + + reg [15:0] ADDR; + assign addr = ADDR; + + reg DIR; + reg [7:0] DATA; + assign data = (DIR == 1) ? DATA : 8'bZZ; + + reg [3:0] COUNT; + + reg [7:0] A, B; + wire [15:0] mul; + assign #1 mul = A * B; + + assign c0 = data[0]; + assign c1 = (COUNT == 4'b0000); + + always @(reset_ == 0) #1 begin + IOR_ <= 1; + IOW_ <= 1; + DIR <= 0; + A <= 0; + COUNT <= 15; + end + + /* + 6 registri operativi + + u-operazioni su ADDR + S1,S2,S4,S5,S6,S7,S8,S10: ADDR<=ADDR + S0: ADDR <= 16'h0120; + S3: ADDR <= 16'h0140; + S9: ADDR <= 16'h0100; + S11: ADDR <= 16'h0101; + + 3 variabili di comando (b2,b1,b0) + + + u-operazioni su COUNT + S0 fino a S13: COUNT <= COUNT - 1; + S14: COUNT <= (COUNT == 0) ? 15 : COUNT - 1; + + 1 variabile di comando (b3) + + u-operazioni su IOR_ + tutti gli altri stati: IOR_<=IOR_ + S1,S10,S12: IOR_<=0 + S2,S11,S14: IOR_<=1 + + 2 variabili di comando (b5,b4) + + + u-operazioni su IOW_ + tutti gli altri stati: IOW_<=IOW_ + S4,S7: IOW_<=0 + S5,S8: IOW_<=1 + + 2 variabili di comando (b7,b6) + + + u-operazioni su B + tutti gli altri stati: B<=B + S2: B <= data; + + 1 variabile di comando (b8) + + b0 + u-operazioni su DATA + tutti gli altri stati: DATA<=DATA + S3: DATA <= mul[15:8]; + S6: DATA <= mul[7:0]; + + 2 variabili di comando (b10,b9) + + + u-operazioni su A + tutti gli altri stati: A<=A + S13: A <= data; + + 1 variabile di comando (b11) + + u-operazioni su DIR + tutti gli altri stati: DIR<=DIR + S3: DIR<=1 + S9: DIR<=0 + + 2 variabili di comando (b13,b12) + */ + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b2,b1,b0}) + 3'b000: ADDR <= ADDR; + 3'b001: ADDR <= 16'h0120; + 3'b010: ADDR <= 16'h0140; + 3'b011: ADDR <= 16'h0100; + 3'b1XX: ADDR <= 16'h0101; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (b3) + 1'b0: COUNT <= COUNT - 1; + 1'b1: COUNT <= (COUNT == 0) ? 15 : COUNT - 1; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b5,b4}) + 2'b00: IOR_ <= IOR_; + 2'b01: IOR_ <= 0; + 2'b1X: IOR_ <= 1; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b7,b6}) + 2'b00: IOW_ <= IOW_; + 2'b01: IOW_ <= 0; + 2'b1X: IOW_ <= 1; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (b8) + 1'b0: B <= B; + 1'b1: B <= data; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b10,b9}) + 2'b00: DATA <= DATA; + 2'b01: DATA <= mul[15:8]; + 2'b1X: DATA <= mul[7:0]; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (b11) + 1'b0: A <= A; + 1'b1: A <= data; + endcase + end + + always @(posedge clock) if(reset_ == 1) #3 begin + casex ({b13,b12}) + 2'b00: DIR <= DIR; + 2'b01: DIR <= 1; + 2'b1X: DIR <= 0; + endcase + end + +endmodule + +module ParteControllo( + clock, reset_, + c1, c0, + b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0 +); + input clock, reset_; + + input c1, c0; + output b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0; + + reg [3:0] STAR; + + localparam + S0 = 0, + S1 = 1, + S2 = 2, + S3 = 3, + S4 = 4, + S5 = 5, + S6 = 6, + S7 = 7, + S8 = 8, + S9 = 9, + S10 = 10, + S11 = 11, + S12 = 12, + S13 = 13, + S14 = 14; + + assign {b13, b12, b11, b10, b9, b8, b7, b6, b5, b4, b3, b2, b1, b0}= + (STAR==S0)? 14'b00000000000001: + (STAR==S1)? 14'b00000000010000: + (STAR==S2)? 14'b000001001X0000: + (STAR==S3)? 14'b01001000000010: + (STAR==S4)? 14'b00000001000000: + (STAR==S5)? 14'b0000001X000000: + (STAR==S6)? 14'b0001X000000000: + (STAR==S7)? 14'b00000001000000: + (STAR==S8)? 14'b0000001X000000: + (STAR==S9)? 14'b1X000000000011: + (STAR==S10)? 14'b00000000010000: + (STAR==S11)? 14'b000000001X01XX: + (STAR==S12)? 14'b00000000010000: + (STAR==S13)? 14'b00100000000000: + (STAR==S14)? 14'b000000001X1000: + /*default*/ 14'b00XXXXXXXXXXXX; + + always @(reset_ == 0) #1 STAR <= S0; + + always @(posedge clock) if(reset_ == 1) #3 begin + casex (STAR) + S0: STAR <= S1; + + S1: STAR <= S2; + + S2: STAR <= S3; + + S3: STAR <= S4; + + S4: STAR <= S5; + + S5: STAR <= S6; + + S6: STAR <= S7; + + S7: STAR <= S8; + + S8: STAR <= S9; + + S9: STAR <= S10; + + S10: STAR <= S11; + + S11: STAR <= (c0==1) ? S12 : S14; + + S12: STAR <= S13; + + S13: STAR <= S14; + + S14: STAR <= (c1==1) ? S0 : S14; + endcase + end + +endmodule \ No newline at end of file