Commits

Ariel Burman committed 408a759

comenzando con el dc_shell

  • Participants
  • Parent commits 65318af

Comments (0)

Files changed (18)

ariel/debug/alarma_tb.v

 `timescale 10us/1us
-//`include "../one_sec_pulse.v"
-//`include "cronometro.v"
 
-//`define PULSOS(dato,cantpulsos) {dato = 0;`\`repeat(cantpulsos) begin`\`#10 dato = 1;`\`#10 __dato = 0;`\`end}
-//`define PULSOS(dato,cantpulsos) {dato = 0; repeat(cantpulsos) begin #10 dato = 1; #10 __dato = 0; end}
-`define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #1 dato = 1; #3 dato = 0; end
+`define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #10 dato = 1; #10 dato = 0; end
 
 module alarma_tb();
 
 reg clk;
 reg nrst;
 reg ndown_up;
-reg s_hr;
-reg s_min;
-reg s_sec;
+reg s_hr, s_hr_prev, s_hr_et;
+reg s_min, s_min_prev, s_min_et;
+reg s_sec, s_sec_prev, s_sec_et;
 reg set_enable;
 reg alarm_enable;
-// 
-// wire [7:0] hora, minutos, segundos, shora, sminutos, ssegundos;
-// wire timeout;
-// wire pulso_1segundo;
+
+reg pulso_sec, pulso_sec_prev, pulso_sec_et;
+
+wire beep_sg, beep_out;
+
 reg [23:0] actual_time;
 wire [23:0] alarm_time;
-wire beep_sg;
+
+always @ (posedge clk) begin
+	if (s_hr == 1 && s_hr_prev == 0) s_hr_et =1;
+	else s_hr_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_min == 1 && s_min_prev == 0) s_min_et =1;
+	else s_min_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_sec == 1 && s_sec_prev == 0) s_sec_et =1;
+	else s_sec_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (pulso_sec == 1 && pulso_sec_prev == 0) pulso_sec_et =1;
+	else pulso_sec_et = 0;
+end
+
+always @ (posedge clk) begin
+	pulso_sec_prev <= pulso_sec;
+	s_hr_prev <= s_hr;
+	s_min_prev <= s_min;
+	s_sec_prev <= s_sec;
+end
 
 alarma Dut (
 	.clk            (clk),
 	.ndown_up       (ndown_up),
 	.set_enable     (set_enable),
 	.alarm_enable   (alarm_enable),
-	.set_hrs        (s_hr),
-	.set_min        (s_min),
-	.set_sec        (s_sec),
+	.set_hrs        (s_hr_et),
+	.set_min        (s_min_et),
+	.set_sec        (s_sec_et),
 	.ihrs_bcd_msd_t (actual_time[23:20]),
 	.ihrs_bcd_lsd_t (actual_time[19:16]),
 	.imts_bcd_msd_t (actual_time[15:12]),
 	.beep           (beep_sg)
 );
 
+buzzer Dut2 (
+	.clk           (clk),
+	.nrst          (nrst),
+	.alarm_sg      (beep_sg),
+	.one_sec_pulse (pulso_sec_et),
+	.buzzer_out    (beep_out)
+);
+
 // Do this in your test bench
 initial begin
 	$dumpfile("salida.vcd");
 	#9 alarm_enable = 1'b1;
 
 	#20 actual_time = {4'd0 , 4'd1 , 4'd2 , 4'd4 , 4'd3 , 4'd3};
-	#50 actual_time = {4'd0 , 4'd3 , 4'd0 , 4'd2 , 4'd2 , 4'd7};
-	#50 actual_time = {4'd0 , 4'd3 , 4'd0 , 4'd2 , 4'd2 , 4'd8};
-	#50 actual_time = {4'd0 , 4'd3 , 4'd0 , 4'd2 , 4'd2 , 4'd9};
-
+	#50 actual_time = {4'd0 , 4'd3 , 4'd0 , 4'd2 , 4'd4 , 4'd4};
+	#50 actual_time = {4'd0 , 4'd3 , 4'd0 , 4'd2 , 4'd4 , 4'd5};
+	#50 actual_time = {4'd0 , 4'd3 , 4'd0 , 4'd2 , 4'd4 , 4'd6};
+	`PULSOS(pulso_sec,62)
 	#9 alarm_enable = 1'b0;
 	#1000000 $finish;
 end

ariel/debug/button_debounce_pro_tb.v

 
 module bt_db_pro ();
 
+wire base_tiempo;
+reg clk;
+reg nrst;
+reg pulsador;
+wire dbout;
+
 one_sec_pulse Base_tiempo (
 	.clk           (clk),
-	.reset_n       (nrst),
-	.enable        (1'b1),
+	.nrst          (nrst),
 	.one_sec_pulse (base_tiempo)
 );
 
-wire base_tiempo;
-
 button_debounce_pro Dut (
 	.ibutton     (pulsador),
 	.clk         (clk),
 	.dbbutton    (dbout)
 );
 
-reg clk;
-//wire clkdiv;
-reg nrst;
-reg pulsador;
-wire dbout;
-
-// Creo el clock. Arreglar el CLK.
-initial
-begin
+initial begin
 	clk = 0;
 	forever #(1/(2*`CLK_FREQ*10e-6)) clk = ~clk;
 end
 
 // Guardo las variables
-initial
-begin
+initial begin
     $dumpfile("salida.vcd");
     $dumpvars(0);
 end
 
-initial
-begin
-		nrst = 1;
-		pulsador = 0;		
-		#5 nrst = 0;
-    #20 nrst = 1;
-    #10 pulsador = 0;
-    #10 pulsador = 1;
-    #10 pulsador = 0;
-    #10 pulsador = 1;
-    #10 pulsador = 1;
-    #10 pulsador = 1;
-    #10 pulsador = 0;
-    #10 pulsador = 0;
-    #10 pulsador = 0;
-    #600 pulsador = 1;
-    #2000000 pulsador = 0;
-    #2000000 pulsador = 1;
-    #2000000 $finish;
+initial begin
+	nrst = 1;
+	pulsador = 0;		
+	#5 nrst = 0;
+  #20 nrst = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 1;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 0;
+  #10 pulsador = 0;
+  #600 pulsador = 1;
+  #2000000 pulsador = 0;
+  #2000000 pulsador = 1;
+  #2000000 $finish;
 end
 endmodule
 

ariel/debug/button_debounce_tb.v

 
 module bt_db ();
 
+wire base_tiempo;
+reg clk;
+//wire clkdiv;
+reg nrst;
+reg pulsador;
+wire dbout;
+
 one_sec_pulse Base_tiempo (
 	.clk           (clk),
-	.reset_n       (nrst),
-	.enable        (1'b1),
+	.nrst          (nrst),
 	.one_sec_pulse (base_tiempo)
 );
 
-wire base_tiempo;
-
 button_debounce Dut (
 	.ibutton     (pulsador),
 	.clk         (clk),
 	.dbbutton    (dbout)
 );
 
-reg clk;
-//wire clkdiv;
-reg nrst;
-reg pulsador;
-wire dbout;
-
-// Creo el clock. Arreglar el CLK.
-initial
-begin
-	clk = 0;
+// Creo el clock.
+initial begin
+	clk <= 0;
 	forever #(1/(2*`CLK_FREQ*10e-6)) clk = ~clk;
 end
 
 // Guardo las variables
-initial
-begin
-    $dumpfile("salida.vcd");
-    $dumpvars(0);
+initial begin
+	$dumpfile("salida.vcd");
+	$dumpvars(0);
 end
 
-initial
-begin
-		nrst = 1;
-		pulsador = 0;		
-		#5 nrst = 0;
-    #20 nrst = 1;
-    #10 pulsador = 0;
-    #10 pulsador = 1;
-    #10 pulsador = 0;
-    #10 pulsador = 1;
-    #10 pulsador = 1;
-    #10 pulsador = 1;
-    #10 pulsador = 0;
-    #10 pulsador = 0;
-    #10 pulsador = 0;
-    #600 pulsador = 1;
-    #2000000 pulsador = 0;
-    #2000000 pulsador = 1;
-    #2000000 $finish;
+initial begin
+	nrst = 1;
+	pulsador = 0;		
+	#5 nrst = 0;
+  #20 nrst = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #600 pulsador = 1;
+  #2500 pulsador = 0;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #2000 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #10 pulsador = 1;
+  #10 pulsador = 0;
+  #10 pulsador = 0;
+  #10 pulsador = 0;
+  #10 pulsador = 1;
+  #2000 $finish;
 end
 endmodule
 

ariel/debug/cont_bcd_2_dig_tb.v

-//`include "cont_bcd_2_dig.v"
 `timescale 100ns/1ns
 
 module cont_bcd_2_dig_tb();
 
 reg clk;
 reg reset_n;
-wire [3:0] A,B;
+wire [3:0] msd,lsd;
 wire flag;
 
 cont_bcd_2_dig #(33) DUT (
-   .clk (clk),
-   .enable (1'b1),
-   .nrst (reset_n),
-   .ndown_up(1'b1),
-	 .bcd_out1(A),
-	 .bcd_out0(B),
-	 .carry(flag)
+	.clk         (clk),
+	.enable      (1'b1),
+	.nrst        (reset_n),
+	.ndown_up    (1'b1),
+	.bcd_out_msd (msd),
+	.bcd_out_lsd (lsd),
+	.carry       (flag)
 );
 
 // Do this in your test bench
 initial begin
-   $dumpfile("salida.vcd");
-   $dumpvars(0);
+	$dumpfile("salida.vcd");
+	$dumpvars(0);
 end
 
 initial begin
-   clk = 1'b0;
-   //forever #1250000 clk = ~clk;
-   forever #(1/(2*CLK_FREQ*100e-9)) clk = ~clk;
+	clk = 1'b0;
+	//forever #1250000 clk = ~clk;
+	forever #(1/(2*CLK_FREQ*100e-9)) clk = ~clk;
 end
 
 initial begin
-   reset_n = 1'b1;
-   #50 reset_n = 1'b0;
-   #10 reset_n = 1'b1;
-   //#(2.0/100e-9) reset_n = 1;
-   #100000000 $finish;
+	reset_n = 1'b1;
+	#50 reset_n = 1'b0;
+	#10 reset_n = 1'b1;
+	//#(2.0/100e-9) reset_n = 1;
+	#100000000 $finish;
 end
 
 endmodule

ariel/debug/cronometro_tb.v

 `timescale 10us/1us
-`define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #3 dato = 1; #3 dato = 0; end
 
-module cronometro_tb(
-output wire [7:0] hora, minutos, segundos, shora, sminutos, ssegundos
-);
+`define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #10 dato = 1; #10 dato = 0; end
+
+module cronometro_tb();
 
 parameter CLK_FREQ = 32768.0; //Clock frequency 32.768kHz
 
 reg clk;
 reg nrst;
-reg s_hr;
-reg s_min;
-reg s_sec;
+reg s_hr, s_hr_prev, s_hr_et;
+reg s_min, s_min_prev, s_min_et;
+reg s_sec, s_sec_prev, s_sec_et;
 reg ndown_up;
 reg set_enable;
 reg start_stop;
 reg cant;
+wire [7:0] hora, minutos, segundos, shora, sminutos, ssegundos;
 
 wire timeout;
 wire pulso_1segundo;
 
-// SACAR PARAMETRO
-one_sec_pulse #(15'd20) Reloj (
+reg [7:0] i;
+wire cable_s_min;
+
+always @ (posedge clk) begin
+	if (s_hr == 1 && s_hr_prev == 0) s_hr_et =1;
+	else s_hr_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_min == 1 && s_min_prev == 0) s_min_et =1;
+	else s_min_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_sec == 1 && s_sec_prev == 0) s_sec_et =1;
+	else s_sec_et = 0;
+end
+
+always @ (posedge clk) begin
+	s_hr_prev <= s_hr;
+	s_min_prev <= s_min;
+	s_sec_prev <= s_sec;
+end
+
+
+one_sec_pulse Reloj (
 	.clk           (clk),
-	.reset_n       (nrst),
-	.enable        (1'b1),
+	.nrst          (nrst),
 	.one_sec_pulse (pulso_1segundo)
 );
 
 cronometro Dut (
 	.clk        (clk),
 	.nrst       (nrst),
-	.s_hr       (s_hr),
-	.s_min      (s_min),
-	.s_sec      (s_sec),
+	.s_hr       (s_hr_et),
+	.s_min      (s_min_et),
+	.s_sec      (s_sec_et),
 	.ndown_up   (ndown_up),
 	.set_enable (set_enable),
 	.start_stop (start_stop),
 	$dumpvars(0);
 end
 
-
 initial begin
 	clk = 1'b0;
-	//forever #1250000 clk = ~clk;
 	forever #(1/(2*CLK_FREQ*10e-6)) clk = ~clk;
 end
 
-reg [7:0] i;
-
-task pulse (input [7:0] cant, output dato);
-begin
-	dato = 0;
-	repeat(cant) begin
-		#10 dato = 1;
-		#10 dato = 0;
-	end
-end
-endtask
-
-wire cable_s_min;
-
 initial begin
 	nrst = 1'b1;
 	start_stop = 1'b0;

ariel/debug/reloj_tb.v

 `timescale 10us/1us
-`define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #3 dato = 1; #3 dato = 0; end
+`define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #10 dato = 1; #10 dato = 0; end
 
 module reloj_tb();
 
 
 reg clk;
 reg nrst;
-reg s_hr;
-reg s_min;
-reg s_sec;
+reg s_hr, s_hr_prev, s_hr_et;
+reg s_min, s_min_prev, s_min_et;
+reg s_sec, s_sec_prev, s_sec_et;
 reg set_enable;
 reg ndown_up;
 
 wire [23:0] tiempo;
 wire pulso_1segundo;
 
-one_sec_pulse #(15'd20) Reloj1sec (
+always @ (posedge clk) begin
+	if (s_hr == 1 && s_hr_prev == 0) s_hr_et =1;
+	else s_hr_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_min == 1 && s_min_prev == 0) s_min_et =1;
+	else s_min_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_sec == 1 && s_sec_prev == 0) s_sec_et =1;
+	else s_sec_et = 0;
+end
+
+always @ (posedge clk) begin
+	s_hr_prev <= s_hr;
+	s_min_prev <= s_min;
+	s_sec_prev <= s_sec;
+end
+
+one_sec_pulse Reloj1sec (
 	.clk           (clk),
-	.reset_n       (nrst),
-	.enable        (1'b1),
+	.nrst          (nrst),
 	.one_sec_pulse (pulso_1segundo)
 );
 
 	.ndown_up   (ndown_up),
 	.time_pulse (pulso_1segundo),
 	.set_enable (set_enable),
-	.set_hrs    (s_hr),
-	.set_min    (s_min),
-	.set_sec    (s_sec),
+	.set_hrs    (s_hr_et),
+	.set_min    (s_min_et),
+	.set_sec    (s_sec_et),
 	.hr_msd     (tiempo[23:20]),
 	.hr_lsd     (tiempo[19:16]),
 	.min_msd    (tiempo[15:12]),

ariel/debug/rtc_tb.v

 `timescale 10us/1us
-//`include "../one_sec_pulse.v"
-//`include "cronometro.v"
 
-//`define PULSOS(dato,cantpulsos) {dato = 0;`\`repeat(cantpulsos) begin`\`#10 dato = 1;`\`#10 __dato = 0;`\`end}
-//`define PULSOS(dato,cantpulsos) {dato = 0; repeat(cantpulsos) begin #10 dato = 1; #10 __dato = 0; end}
 `define PULSOS(dato,cantpulsos) dato = 0; repeat(cantpulsos) begin #100 dato = 1; #100 dato = 0; end
 
 module rtc_tb();
 reg irs;
 reg its;
 reg idu;
-reg ihr, imin, isec;
+reg s_hr, s_hr_prev, s_hr_et;
+reg s_min, s_min_prev, s_min_et;
+reg s_sec, s_sec_prev, s_sec_et;
 reg iss;
 reg iaoo, iars, ia1, ia2, ia3;
 wire [7:0] d1,d2,d3,d4,d5,d6;
 wire to,bp;
 
+
+always @ (posedge clk) begin
+	if (s_hr == 1 && s_hr_prev == 0) s_hr_et =1;
+	else s_hr_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_min == 1 && s_min_prev == 0) s_min_et =1;
+	else s_min_et = 0;
+end
+
+always @ (posedge clk) begin
+	if (s_sec == 1 && s_sec_prev == 0) s_sec_et =1;
+	else s_sec_et = 0;
+end
+
+always @ (posedge clk) begin
+	s_hr_prev <= s_hr;
+	s_min_prev <= s_min;
+	s_sec_prev <= s_sec;
+end
+
+
 rtc Dut(
 	.clk              (clk),
 	.reset_n          (nrst),
 	.irun_setn        (irs),
 	.itime_stopwn     (its),
 	.idown_upn        (idu),
-	.ihrs             (ihr),
-	.imts             (imin),
-	.isecs            (isec),
+	.ihrs             (s_hr_et),
+	.imts             (s_min_et),
+	.isecs            (s_sec_et),
 	.istart_stopn     (iss),
 	.ialarm_off_on    (iaoo),
 	.ialarm_read_setn (iars),
 	irs = 1;
 	its = 1;
 	idu = 0;
-	ihr = 0;
-	imin = 0;
-	isec = 0;
+	s_hr = 0;
+	s_min = 0;
+	s_sec = 0;
 	iss = 0;
 	iaoo = 0;
 	iars = 0;
 	#20000000 its = 0;
 	#10 irs = 0;
 
-	`PULSOS(isec,20)
-
+	`PULSOS(s_sec,20)
+	`PULSOS(s_min,12)
+	`PULSOS(s_hr,20)
+	
 	#100 irs = 1;
 	
 	#5000000 $finish;

ariel/rtl/alarma.v

 /* Modulo que contiene la funcionalidad de alarmar para el reloj.
+*  Genera un nivel alto cuando la hora actual coincide con la hora de alarma
+*  seteada.
 */
-//`timescale 1us/100ns
-
-`define ALARM 1'b1
-`define IDLE 1'b0
 
 /*
 alarma Dut (
 
 module alarma (
 	input clk,
-	input nrst,
-	input ndown_up,
+	input nrst, // se resetea con nivel bajo 0
+	input ndown_up, // si es 0, el seteo de la hora se hace en forma decreciente.
+									// si es 1, es el caso contrario
 
 	// Control switches
-	input set_enable,
-	input alarm_enable,
+	input set_enable, // cuando esta en 1 se puede modificar la hora de alarma
+										// seteada
+	input alarm_enable, // cuando esta en 1 la alarma esta activada
 
 	// Set push-buttons
 	input set_hrs,
 	output reg [3:0] osec_bcd_lsd,
 
 	// Alarm output
-	output reg beep
+	output reg beep  // genera un nivel alto cuando la hora actual coincide con la
+									 // hora almacenada. Esto se debe utilizar para activar el buzzer
 );
 
 reg state;
 
 assign actual_time = {ihrs_bcd_msd_t, ihrs_bcd_lsd_t, imts_bcd_msd_t, imts_bcd_lsd_t, isec_bcd_msd_t, isec_bcd_lsd_t};
 
+// Modulos para almacenar la hora de la alarma. No se utiliza el carry porque no
+// se desea que cambien los otros digitos al llegar al overflow.
 cont_bcd_2_dig #(8'd24) hora (
-	.clk      (clk),
-	.nrst     (nrst),
-	.enable   (set_hrs & set_enable),
-	.ndown_up (ndown_up),
-	.bcd_out1 (alarm_time[23:20]),
-	.bcd_out0 (alarm_time[19:16]),
-	.carry    ()
+	.clk         (clk),
+	.nrst        (nrst),
+	.enable      (set_hrs & set_enable),
+	.ndown_up    (ndown_up),
+	.bcd_out_msd (alarm_time[23:20]),
+	.bcd_out_lsd (alarm_time[19:16]),
+	.carry       ()
 );
 
 cont_bcd_2_dig #(8'd60) minutos (
-	.clk      (clk),
-	.nrst     (nrst),
-	.enable   (set_min & set_enable),
-	.ndown_up (ndown_up),
-	.bcd_out1 (alarm_time[15:12]),
-	.bcd_out0 (alarm_time[11:08]),
-	.carry    ()
+	.clk         (clk),
+	.nrst        (nrst),
+	.enable      (set_min & set_enable),
+	.ndown_up    (ndown_up),
+	.bcd_out_msd (alarm_time[15:12]),
+	.bcd_out_lsd (alarm_time[11:08]),
+	.carry       ()
 );
 
 cont_bcd_2_dig #(8'd60) segundos (
-	.clk      (clk),
-	.nrst     (nrst),
-	.enable   (set_sec & set_enable),
-	.ndown_up (ndown_up),
-	.bcd_out1 (alarm_time[7:4]),
-	.bcd_out0 (alarm_time[3:0]),
-	.carry    ()
+	.clk         (clk),
+	.nrst        (nrst),
+	.enable      (set_sec & set_enable),
+	.ndown_up    (ndown_up),
+	.bcd_out_msd (alarm_time[7:4]),
+	.bcd_out_lsd (alarm_time[3:0]),
+	.carry       ()
 );
 
+parameter ALARM=1'b1,IDLE=1'b0;
+
 always @(posedge clk) begin
-	if (nrst == 0) state <= `IDLE;
+	if (nrst == 0) state <= IDLE;
 	else state <= next;
 end
 
 always @(alarm_time) {ohrs_bcd_msd, ohrs_bcd_lsd, omts_bcd_msd, omts_bcd_lsd, osec_bcd_msd, osec_bcd_lsd} = alarm_time;
 
 always @(state, alarm_enable, set_enable, alarm_time, actual_time) begin
-	next = `IDLE;
+	next = IDLE;
 	case (state)
-  `IDLE:
+  IDLE:
 		if (alarm_enable == 1 && set_enable == 0 && alarm_time == actual_time)
-			next = `ALARM;
-	`ALARM:
+			next = ALARM;
+	ALARM:
 		if (alarm_enable == 1 && set_enable == 0)
-			next = `ALARM;
+			next = ALARM;
 	endcase
 end
 
-// corregir el delay de un clk en el cambio de estado
-// ver la senial de beep en el testbench
-
 always @(posedge clk or negedge nrst) begin
-	if (nrst == 0)
-		beep <= 0;
+	if (nrst == 0) beep <= 0;
 	else
 		case (state)
-		`IDLE:
-		 	beep <= 0;
-		`ALARM:
-			beep <= 1;
+			IDLE:  beep <= 0;
+			ALARM: beep <= 1;
 		endcase
 end
 

ariel/rtl/bcd_to_7seg.v

-// Modulo para transformar bcd a 7 segmentos.
-//`timescale 1us/100ns
+/* Modulo para transformar bcd a 7 segmentos.
+*  Se asume que el los leds encienden con un nivel bajo y que el orden de los
+*  pines de salida es {dp,a,b,c,d,e,f,g}.
+*  Tambien puede mostrar los caracteres hexadecimales.
+*/
 
 /*
 bcd_to_7seg Dut (
 */
 
 module bcd_to_7seg (
+	input clk,
 	input [3:0] bcd,
 	output reg [7:0] segments
 );
 
 // 0: LED on ; 1: LED off  => [7:0] = {dp,a,b,c,d,e,f,g}
-always @(bcd) begin
+always @(posedge clk) begin
 	case (bcd)
 		4'h0: segments <= 8'b10000001;
 		4'h1: segments <= 8'b11001111;
 		4'h7: segments <= 8'b10001111;
 		4'h8: segments <= 8'b10000000;
 		4'h9: segments <= 8'b10000100;
-/*		4'hA: segments <= 8'b10001000;
-		4'hB: segments <= 8'b11100000;
-		4'hC: segments <= 8'b10110001;
-		4'hD: segments <= 8'b11000010;
-		4'hE: segments <= 8'b10110000;
-		4'hF: segments <= 8'b10111000;
+/*		4'hA: segments <= 8'b10001000; // A
+		4'hB: segments <= 8'b11100000;  // b
+		4'hC: segments <= 8'b10110001;  // C
+		4'hD: segments <= 8'b11000010;  // d
+		4'hE: segments <= 8'b10110000;  // E
+		4'hF: segments <= 8'b10111000;  // F
 */		default: segments <= 8'b11111111;
 	endcase
 end

ariel/rtl/button_debounce.v

-/* Maquina de estados para generar la senal de ibutton.
+/* Maquina de estados para hacer el debounce de los pulsadores de entrada
 * Estado IDLE = no se esta apretando el boton.
 * Estado click = se paso el debounce
-* Estado click_largo = se superaron los 2 segundos.
-* Genera un tren de pulsos de diferentes velocidades.
-* Los botones de ibutton, al apretarse valen 1.
 */
-//`timescale 1us/100ns
 
 /*
-button_debounce_pro Dut (
+button_debounce Dut (
 	.ibutton     (),
 	.clk         (),
 	.clk_one_sec (),
 reg [1:0] state, next; // registros para el estado actual y el siguiente.
 reg [`DELAY-1:0] int_counter; // registro para el contador del delay de debounce
 reg tick; // señal que indica que pasó el tiempo de debounce.
-reg single; // señal que indica si tengo que generar un unico pulso de ibutton.
-reg int_clk_set; // señal interna que se usa para generar los flancos de dbbutton.
-reg int_clk_set_ant; // señal que necesito para hacer el pulso. Guarda el estado 
-                     // anterior de int_clk_set_ant.
-										 //
-// Genero un flanco de ancho un clk cuando tengo que generar el pulso de
-// ibutton. Esto conecta el int_clk_set con dbbutton.
-always @(posedge clk) begin
-	dbbutton <= 0;
-	if (int_clk_set == 1 && int_clk_set_ant == 0)
-		dbbutton <= 1;
-	if (int_clk_set == 1 && int_clk_set_ant == 1)
-		dbbutton <= 0;
-	int_clk_set_ant <= int_clk_set;
-end
-
-/* Contador de delay para el debounce. Se asume que el pulso es válido
-* después de un tick. Para ajustar el largo, hay que agregar flip flips
-* al contador. (cambiando el parámetro DELAY).
-*/
-always @(posedge clk or negedge nRESET) begin
-	if (nRESET == 1'b0) begin
-		tick <= 0;
-		int_counter <= 0;
-	end
-	else {tick, int_counter} <= int_counter + 1;
-end
-
-// Este bloque genera la señal interna de clk_reset. Los flancos de esta
-// señal indican que hay que incrementar una cuenta el contador destino.
-always @(posedge clk or negedge nRESET) begin
-	if (nRESET == 1'b0) begin
-		int_clk_set <= 0;
-	end
-	/* Acá no me preocupo por el largo del pulso de ibutton.
-	* lo que importa es el flanco. Otro bloque me lo convierte
-	* a pulsos de un clk de largo.
-	*/
-	else if (tick == 1'b1) begin
-		if (single == 1'b1) int_clk_set <= 1;
-		else int_clk_set <= 0;
-	end
-	//else
-	//	int_clk_set <= 0;
-end
 
 // Bloque always para actualizar el estado de la maquina de estados.
-always @(posedge clk or negedge nRESET)
-begin
+always @(posedge clk or negedge nRESET) begin
 	if (nRESET == 1'b0) state <= IDLE;
 	else state <= next;
 end
 
-/* Calculo del siguiente estado y la salida.
-* este always es sensible a las cosas que hacen
-* cambiar el estado solamente. Es lo que remienda
-* el paper de las maquinas de estado. Más normal
-* es poner always@* (y antes si no se hacía así
-* no andaba en iverilog.
-*/
-always @(state, clk_one_sec, tick, ibutton) begin
+// Calculo del siguiente estado.
+always @(state, tick, ibutton) begin
 	next = IDLE; //Valores más comunes para evitar repetirlos.
-	single = 0;
 	case (state)
 		IDLE: // No hay nada apretado.
 			if (ibutton == 1'b1) next = WAIT_1;
 					// Si no se cumple ninguna, vuelvo a IDLE por omisión.
 		CLICK: // Detecté un click correcto.
 			if (ibutton == 1'b1) begin
-				single = 1;   // Si todavía no pasó un segundo, pulso.
 				next = CLICK; // y sigo esperando.
 			end
 	endcase
 end
 
+// El contador funciona cuando se esta en el estado wait.
+// cuando completa la cuenta, pone un 1 en tick y eso generara el cambio de
+// estado en el siguiente ciclo de clk
+always @ (posedge clk) begin
+	if (state == WAIT_1) 
+		{tick, int_counter} <= int_counter + 1;
+	else begin
+		tick <= 0;
+		int_counter <= 0;
+	end
+end
+
+// genera un pulso de un ciclo de clk de duracion, indicando que hubo un click
+always @ (posedge clk) begin
+	if (next == CLICK && state == WAIT_1)
+		dbbutton <= 1;
+	else // if (int_clk_set == 1 && int_clk_set_ant == 1)
+		dbbutton <= 0;
+end
+
 endmodule

ariel/rtl/buzzer.v

+/* Este modulo se encarga de mantener la alarma encendida por 30 segundos */
+
+/*
+buzzer #(.SECS(5'd30)) Dut (
+	.clk           (),
+	.nrst          (),
+	.alarm_sg      (),
+	.one_sec_pulse (),
+	.buzzer_out    ()
+);
+*/
+
+// la maxima cantidad de segundos que puede mantenerse la alarma encendida es
+// 2^CUENTA_MAX. Si se usa un valor de SECS mayor el comportamiento no esta
+// definido
+//`define CUENTA_MAX 5
+`define SECS 5'd30
+
+module buzzer (
+	input clk,
+	input nrst,
+	input alarm_sg, // con un cambio de nivel de cero a uno, genera un pulso de SECS segundos
+	input one_sec_pulse,
+	output reg buzzer_out // mantiene en 1 la salida durante SECS segundos
+);
+
+reg [4:0] cuenta;
+reg prev_alarm_sg, pulse;
+reg state,next;
+parameter IDLE = 1'b0,CONTANDO = 1'b1;
+
+always @ (posedge clk, negedge nrst) begin
+	if (nrst == 1'b0) begin
+		cuenta <= 0;
+		next <= 0;
+		state <= 0;
+		prev_alarm_sg = 0;
+	end
+	else
+		state <= next;
+end
+
+always @ (posedge clk) begin
+	if ((prev_alarm_sg == 1'b0) && (alarm_sg == 1'b1)) pulse <= 1'b1;
+	else pulse <= 1'b0;
+	prev_alarm_sg <= alarm_sg;
+end
+
+always @ (pulse,cuenta,state) begin
+	case (state)
+		IDLE:
+			if (pulse == 1'b1) next = CONTANDO;
+			else next = IDLE;
+		CONTANDO:
+			if (cuenta == `SECS) next = IDLE;
+			else next = CONTANDO;
+	endcase
+end
+
+always @ (posedge clk) 
+	if (one_sec_pulse == 1'b1 && state == CONTANDO) cuenta <= cuenta + 1;
+
+endmodule

ariel/rtl/cont_bcd_2_dig.v

-//`timescale 1us/100ns
+/* Este modulo es el contador de 2 digitos en bcd parametrizable. Se lo utiliza
+ * tanto para contar hasta 60 o hasta 24. Cuenta en ambas direcciones y la
+ * salida de carry se utiliza para interconectar modulos en cascada 
+*/
 
 /*
-cont_bcd_2_dig #(.CUENTA_TOP(8'd60)) DUT
-(
-	clk      (),
-	enable   (), // si enable = 1, cuenta con cada flanco positivo de clk
-	nrst     (), // se resetea con 0 por nivel
-	ndown_up (), // 0 => cuenta para abajo; 1 => para arriba
-	bcd_out1 (), // mas significativo
-	bcd_out0 (), // menos significativo
-	carry    ()
+cont_bcd_2_dig #(.CUENTA_TOP(8'd60)) DUT (
+	clk         (),
+	enable      (), 
+	nrst        (), 
+	ndown_up    (), 
+	bcd_out_msd (), 
+	bcd_out_lsd (), 
+	carry       ()
 );
 */
 
-module cont_bcd_2_dig 
-#( parameter CUENTA_TOP = 8'd60)
-(
+module cont_bcd_2_dig #( parameter CUENTA_TOP = 8'd60) (
 	input clk,
 	input enable, // si enable = 1, cuenta con cada flanco positivo de clk
-	input nrst, // se resetea con 0 por nivel
-	input ndown_up, // 0 => cuenta para abajo; 1 => para arriba
-	output reg [3:0] bcd_out1, // mas significativo
-	output reg [3:0] bcd_out0, // menos significativo
-	output carry
+	input nrst,   // se resetea con 0 por nivel
+	input ndown_up,   // 0 => cuenta para abajo; 1 => para arriba
+	output reg [3:0] bcd_out_msd, // mas significativo
+	output reg [3:0] bcd_out_lsd, // menos significativo
+	output carry  // el carry es 1 cuando en el siguiente pulso de clk
+								// el contador llegará hasta uno de sus extremos (CUENTA_TOP en
+								// el caso de contar hacia arriba y 0 en caso contrario).  De
+								// esta permite actualizar al modulo concurrente, en el
+								// siguiente ciclo de clk
 );
 
-//reg [7:0] cuenta; // registros para los dos digitos BCD
 reg flag;
-//assign bcd_out1 = cuenta[7:4];
-//assign bcd_out0 = cuenta[3:0];
 assign carry = flag & enable;
 
 always @ (posedge clk, negedge nrst) begin
-	if (nrst == 1'b0) begin
-		{bcd_out1,bcd_out0} = 8'b0;
-	end
+	if (nrst == 1'b0)
+		{bcd_out_msd,bcd_out_lsd} = 8'b0;
 	else if (enable == 1'b1) begin
 		if (ndown_up == 1'b0) begin
-			{bcd_out1,bcd_out0} = {bcd_out1,bcd_out0} - 8'b1;
-			if ({bcd_out1,bcd_out0} == -8'd1) begin
-				{bcd_out1,bcd_out0} = ((((CUENTA_TOP-1)/10)<<4) | ((CUENTA_TOP-1)%10));
+			{bcd_out_msd,bcd_out_lsd} = {bcd_out_msd,bcd_out_lsd} - 8'b1;
+			if ({bcd_out_msd,bcd_out_lsd} == -8'd1) begin
+				{bcd_out_msd,bcd_out_lsd} = ((((CUENTA_TOP-1)/10)<<4) | ((CUENTA_TOP-1)%10));
 			end
 			else begin
-				if ({bcd_out1[3],bcd_out1[2]} == 2'b11)
-					{bcd_out1,bcd_out0} = {bcd_out1,bcd_out0} - (8'd6 << 4);
-				if ({bcd_out0[3],bcd_out0[2]} == 2'b11) 
-					{bcd_out1,bcd_out0} = {bcd_out1,bcd_out0} - 8'd6;
+				if ({bcd_out_msd[3],bcd_out_msd[2]} == 2'b11)
+					{bcd_out_msd,bcd_out_lsd} = {bcd_out_msd,bcd_out_lsd} - (8'd6 << 4);
+				if ({bcd_out_lsd[3],bcd_out_lsd[2]} == 2'b11) 
+					{bcd_out_msd,bcd_out_lsd} = {bcd_out_msd,bcd_out_lsd} - 8'd6;
 			end
 		end
 		else begin
-			{bcd_out1,bcd_out0} = {bcd_out1,bcd_out0} + 8'b1;
-			if ({bcd_out0[3],bcd_out0[1]} == 2'b11) begin
-				{bcd_out1,bcd_out0} = {bcd_out1,bcd_out0} + 8'd6;
-				if ({bcd_out1[3],bcd_out1[1]} == 2'b11)
-					{bcd_out1,bcd_out0} = {bcd_out1,bcd_out0} + (8'd6 << 4);
+			{bcd_out_msd,bcd_out_lsd} = {bcd_out_msd,bcd_out_lsd} + 8'b1;
+			if ({bcd_out_lsd[3],bcd_out_lsd[1]} == 2'b11) begin
+				{bcd_out_msd,bcd_out_lsd} = {bcd_out_msd,bcd_out_lsd} + 8'd6;
+				if ({bcd_out_msd[3],bcd_out_msd[1]} == 2'b11)
+					{bcd_out_msd,bcd_out_lsd} = {bcd_out_msd,bcd_out_lsd} + (8'd6 << 4);
 			end
-			if ({bcd_out1,bcd_out0} == ((CUENTA_TOP /10<<4) | (CUENTA_TOP % 10))) begin
-				{bcd_out1,bcd_out0} = 8'b0;
+			if ({bcd_out_msd,bcd_out_lsd} == ((CUENTA_TOP /10<<4) | (CUENTA_TOP % 10))) begin
+				{bcd_out_msd,bcd_out_lsd} = 8'b0;
 			end
 		end
 	end
 end
 
-always @ (ndown_up,bcd_out1,bcd_out0) begin
+always @ (ndown_up,bcd_out_msd,bcd_out_lsd) begin
 	if (ndown_up == 1'b0)
-		if ({bcd_out1,bcd_out0} == 8'd0) flag = enable;
+		if ({bcd_out_msd,bcd_out_lsd} == 8'd0) flag = enable;
 		else flag = 1'b0;
 	else
-		if ({bcd_out1,bcd_out0} == ( (((CUENTA_TOP-1)/10)<<4) | ((CUENTA_TOP-1)%10) ) )
+		if ({bcd_out_msd,bcd_out_lsd} == ( (((CUENTA_TOP-1)/10)<<4) | ((CUENTA_TOP-1)%10) ) )
 			flag = enable;
 		else flag = 1'b0;
 end

ariel/rtl/cronometro.v

-//`timescale 1us/100ns
-
+/* Este modulo implenta el cronometro */
 /*
 cronometro DUT (
 	.clk        (),
 	output reg time_out
 );
 
-//wire [7:0] set_hr, set_min, set_sec;
-//wire [7:0] hr, min, sec;
-
 reg soft_rst;
 reg prev_start_stop,run;
 parameter STOP = 3'b000, CRON_UP_S = 3'b100, CRON_UP = 3'b101, CRON_DOWN_S = 3'b110, CRON_DOWN = 3'b111, SET = 3'b001;
 wire [3:0] wset_sec_l, wset_sec_h, wset_min_l, wset_min_h, wset_hr_l, wset_hr_h;
 
 cont_bcd_2_dig #(8'd24) hora (
-		.clk        (clk),
-		.nrst       (nrst&soft_rst),
-		.enable     (enable_hr),
-		.ndown_up   (ndown_up),
-		.bcd_out0   (whr_l),
-		.bcd_out1   (whr_h),
-		.carry      ()
+		.clk         (clk),
+		.nrst        (nrst&soft_rst),
+		.enable      (enable_hr),
+		.ndown_up    (ndown_up),
+		.bcd_out_msd (whr_h),
+		.bcd_out_lsd (whr_l),
+		.carry       ()
 );
 
 cont_bcd_2_dig #(8'd60) minutos (
-		.clk        (clk),
-		.nrst       (nrst&soft_rst),
-		.enable     (enable_min),
-		.ndown_up   (ndown_up),
-		.bcd_out0   (wmin_l),
-		.bcd_out1   (wmin_h),
-		.carry      (carry_min)
+		.clk         (clk),
+		.nrst        (nrst&soft_rst),
+		.enable      (enable_min),
+		.ndown_up    (ndown_up),
+		.bcd_out_msd (wmin_h),
+		.bcd_out_lsd (wmin_l),
+		.carry       (carry_min)
 );
 
 cont_bcd_2_dig #(8'd60) segundos (
-		.clk        (clk),
-		.nrst       (nrst&soft_rst),
-		.enable     (enable_sec),
-		.ndown_up   (ndown_up),
-		.bcd_out0   (wsec_l),
-		.bcd_out1   (wsec_h),
-		.carry      (carry_sec)
+		.clk         (clk),
+		.nrst        (nrst&soft_rst),
+		.enable      (enable_sec),
+		.ndown_up    (ndown_up),
+		.bcd_out_msd (wsec_h),
+		.bcd_out_lsd (wsec_l),
+		.carry       (carry_sec)
 );
 
 // los siguientes registros guardan la hora seteada
 cont_bcd_2_dig #(8'd24) set_hora (
-		.clk        (clk),
-		.nrst       (nrst),
-		.enable     (s_hr & set_enable),
-		.ndown_up   (ndown_up),
-		.bcd_out0   (wset_hr_l),
-		.bcd_out1   (wset_hr_h),
-		.carry      ()
+		.clk         (clk),
+		.nrst        (nrst),
+		.enable      (s_hr & set_enable),
+		.ndown_up    (ndown_up),
+		.bcd_out_msd (wset_hr_h),
+		.bcd_out_lsd (wset_hr_l),
+		.carry       ()
 );
 
 cont_bcd_2_dig #(8'd60) set_minutos (
-		.clk        (clk),
-		.nrst       (nrst),
-		.enable     (s_min & set_enable),
-		.ndown_up   (ndown_up),
-		.bcd_out0   (wset_min_l),
-		.bcd_out1   (wset_min_h),
-		.carry      ()
+		.clk         (clk),
+		.nrst        (nrst),
+		.enable      (s_min & set_enable),
+		.ndown_up    (ndown_up),
+		.bcd_out_msd (wset_min_h),
+		.bcd_out_lsd (wset_min_l),
+		.carry       ()
 );
 
 cont_bcd_2_dig #(8'd60) set_segundos (
-		.clk        (clk),
-		.nrst       (nrst),
-		.enable     (s_sec & set_enable),
-		.ndown_up   (ndown_up),
-		.bcd_out0   (wset_sec_l),
-		.bcd_out1   (wset_sec_h),
-		.carry      ()
+		.clk         (clk),
+		.nrst        (nrst),
+		.enable      (s_sec & set_enable),
+		.ndown_up    (ndown_up),
+		.bcd_out_msd (wset_sec_h),
+		.bcd_out_lsd (wset_sec_l),
+		.carry       ()
 );
 
 always @ (posedge clk or negedge nrst) begin

ariel/rtl/one_sec_pulse.v

-//`timescale 1us/100ns
+/* Este modulo genera un pulso de un ciclo de clk de duracion, cada 2^15 ciclos
+ * de clk */
 
 /*
 one_sec_pulse DUT (
 	.clk           (),
 	.reset_n       (),
-	.enable        (),
 	.one_sec_pulse ()
 );
 */
 
 module one_sec_pulse (
    input clk,
-   input reset_n,
-   input enable,
-   output reg one_sec_pulse
+   input nrst,
+   output one_sec_pulse
 );
 
-parameter [15:0] CLK_FREQ = 32768; //Clock frequency 32.768kHz
+reg carry; // = 1'b0; // uso un bit mas para marcar el carry
+reg [14:0] counter; // = 15'b0; // creo un contador de 15 bits.
 
-reg [15:0] cont_one_sec;
+assign one_sec_pulse = carry;
 
-always @(posedge clk or negedge reset_n) begin
-   if (!reset_n) begin
-      one_sec_pulse <= 1'b0;
-      cont_one_sec <= 15'd0;
-   end
-   else begin
-      if (enable) begin
-         if (cont_one_sec == CLK_FREQ-1) begin
-            one_sec_pulse <= 1'b1;
-            cont_one_sec <= 16'd0;
-         end
-         else begin
-            one_sec_pulse <= 1'b0;
-            cont_one_sec <= cont_one_sec + 1;
-         end
-      end
-      else begin
-         one_sec_pulse <= 1'b0;
-         cont_one_sec <= 16'd0;
-      end
-   end
+always @(posedge clk or negedge nrst) begin
+	if (nrst == 1'b0) begin
+		counter <= 15'b0;
+		carry <= 1'b0;
+	end
+  else {carry, counter} <= counter + 1;
 end
 
 endmodule

ariel/rtl/reloj.v

-//`timescale 1us/100ns
+/* Este modulo es el reloj basico. solo cuenta hacia arriba */
 
 /*
 reloj Dut (
 assign sec_enable = (set_enable == 1'b1) ? set_sec : time_pulse;
 
 cont_bcd_2_dig #(8'd24) hora (
-	.clk      (clk),
-	.nrst     (nrst),
-	.enable   (hr_enable),
-	.ndown_up (ndown_up | ~set_enable),
-	.bcd_out0 (hr_lsd),
-	.bcd_out1 (hr_msd),
-	.carry    ()
+	.clk         (clk),
+	.nrst        (nrst),
+	.enable      (hr_enable),
+	.ndown_up    (ndown_up | ~set_enable),
+	.bcd_out_msd (hr_msd),
+	.bcd_out_lsd (hr_lsd),
+	.carry       ()
 );
 
 cont_bcd_2_dig #(8'd60) minutos (
-	.clk      (clk),
-	.nrst     (nrst),
-	.enable   (min_enable),
-	.ndown_up (ndown_up | ~set_enable),
-	.bcd_out0 (min_lsd),
-	.bcd_out1 (min_msd),
-	.carry    (carry_min)
+	.clk         (clk),
+	.nrst        (nrst),
+	.enable      (min_enable),
+	.ndown_up    (ndown_up | ~set_enable),
+	.bcd_out_msd (min_msd),
+	.bcd_out_lsd (min_lsd),
+	.carry       (carry_min)
 );
 
 cont_bcd_2_dig #(8'd60) segundos (
-	.clk      (clk),
-	.nrst     (nrst),
-	.enable   (sec_enable),
-	.ndown_up (ndown_up | ~set_enable),
-	.bcd_out0 (sec_lsd),
-	.bcd_out1 (sec_msd),
-	.carry    (carry_sec)
+	.clk         (clk),
+	.nrst        (nrst),
+	.enable      (sec_enable),
+	.ndown_up    (ndown_up | ~set_enable),
+	.bcd_out_msd (sec_msd),
+	.bcd_out_lsd (sec_lsd),
+	.carry       (carry_sec)
 );
 
 endmodule
-//`timescale 1us/100ns
+/* Real Time Clock */
 
 /*
 rtc Dut(
 );
 */
 
+// Para las siguientes entradas se describe cual fue el comportamiento
+// interpretado. En caso de que no sea el correcto, solo hay que negar las
+// señales correspondientes
 module rtc (
-   input clk,
-   input reset_n,
-   input irun_setn,
-   input itime_stopwn,
-   input idown_upn,
-   input ihrs,
-   input imts,
-   input isecs,
-   input istart_stopn,
-   input ialarm_off_on,
-   input ialarm_read_setn,
-   input ialarm1,
-   input ialarm2,
-   input ialarm3,
-   output [7:0] display1,
-   output [7:0] display2,
-   output [7:0] display3,
-   output [7:0] display4,
-   output [7:0] display5,
-   output [7:0] display6,
-   output beep,
-   output timer_out
+	input clk,     // asume un clk de entrada de 2^15 khz
+	input reset_n, // 0 se resetea el rtc, 1 funcionamiento normal
+	input irun_setn, // 0 -> set || 1-> rum
+	input itime_stopwn, // 0 -> cronometro || 1-> reloj
+	input idown_upn, // 0 -> arriba || 1-> abajo
+	input ihrs,      // 1-> pulsado
+	input imts,      // 1-> pulsado
+	input isecs,     // 1-> pulsado
+	input istart_stopn, // 1-> start || 0-> stop
+	input ialarm_off_on, // 1-> on || 0-> off
+	input ialarm_read_setn, // 1-> read || 0-> set
+	input ialarm1,    // 1 -> seleccionada
+	input ialarm2,    // 1 -> seleccionada
+	input ialarm3,    // 1 -> seleccionada
+	output [7:0] display1, // los leds de los displays, se prenden con 0
+	output [7:0] display2,
+	output [7:0] display3,
+	output [7:0] display4,
+	output [7:0] display5,
+	output [7:0] display6,
+	output beep,     // 1 -> sonido
+	output timer_out // 1 -> fin de crometro
 );
 
 reg ndup;
+wire base_tiempo;
+wire db_hr,db_min,db_sec,db_start_stop;
+wire [23:0] tiempo_actual;
+wire [23:0] tiempo_cron;
+wire [23:0] tiempo_al1;
+wire [23:0] tiempo_al2;
+wire [23:0] tiempo_al3;
+wire cron_tmo;
+wire al1_bp, al2_bp, al3_bp;
+reg al1set, al2set, al3set;
+reg beep_r;
+reg [23:0]digitos_salida;
 
-always @ (idown_upn)
- 	ndup = (~idown_upn);
-
-wire base_tiempo;
-
-wire db_hr,db_min,db_sec,db_start_stop;
-
-button_debounce_pro debounce_hora (
+button_debounce_pro Debounce_hora (
 	.ibutton     (ihrs),
 	.clk         (clk),
 	.clk_one_sec (base_tiempo),
 	.dbbutton    (db_hr)
 );
 
-button_debounce_pro debounce_minutos (
+button_debounce_pro Debounce_minutos (
 	.ibutton     (imts),
 	.clk         (clk),
 	.clk_one_sec (base_tiempo),
 	.dbbutton    (db_min)
 );
 
-button_debounce_pro debounce_segundos (
+button_debounce_pro Debounce_segundos (
 	.ibutton     (isecs),
 	.clk         (clk),
 	.clk_one_sec (base_tiempo),
 	.dbbutton    (db_sec)
 );
 
-button_debounce debounce_startstop (
+button_debounce Debounce_startstop (
 	.ibutton     (istart_stopn),
 	.clk         (clk),
 	.clk_one_sec (base_tiempo),
 	.dbbutton    (db_start_stop)
 );
 
-wire [23:0] tiempo_actual;
-wire [23:0] tiempo_cron;
-wire [23:0] tiempo_al1;
-wire [23:0] tiempo_al2;
-wire [23:0] tiempo_al3;
-
 one_sec_pulse Base_tiempo (
 	.clk           (clk),
-	.reset_n       (reset_n),
-	.enable        (1'b1),
+	.nrst          (reset_n),
 	.one_sec_pulse (base_tiempo)
 );
 
 	.sec_lsd    (tiempo_actual[03:00])
 );
 
-wire cron_tmo;
-
 cronometro Stopwatch (
 	.clk        (clk),
 	.nrst       (reset_n),
 	.time_out   (cron_tmo)
 );
 
-wire al1_bp, al2_bp, al3_bp;
-reg al1set, al2set, al3set;
-
 alarma Alarma1 (
 	.clk            (clk),
 	.nrst           (reset_n),
 	.beep           (al3_bp)
 );
 
-//reg set_time,set_cron;
+buzzer Parlante (
+	.clk           (clk),
+	.nrst          (reset_n),
+	.alarm_sg      (beep_r),
+	.one_sec_pulse (base_tiempo),
+	.buzzer_out    (beep)
+);
+
+bcd_to_7seg Hr_h_7_seg (
+	.clk           (clk),
+	.bcd (digitos_salida[23:20]),
+	.segments (display1)
+);
+
+bcd_to_7seg Hr_l_7_seg (
+	.clk           (clk),
+	.bcd (digitos_salida[19:16]),
+	.segments (display2)
+);
+
+bcd_to_7seg Min_h_7_seg (
+	.clk           (clk),
+	.bcd (digitos_salida[15:12]),
+	.segments (display3)
+);
+
+bcd_to_7seg Min_l_7_seg (
+	.clk           (clk),
+	.bcd (digitos_salida[11:08]),
+	.segments (display4)
+);
+
+bcd_to_7seg Sec_h_7_seg (
+	.clk           (clk),
+	.bcd (digitos_salida[07:04]),
+	.segments (display5)
+);
+
+bcd_to_7seg Sec_l_7_seg (
+	.clk           (clk),
+	.bcd (digitos_salida[03:00]),
+	.segments (display6)
+);
+
+always @ (idown_upn) ndup = (~idown_upn);
 
 //entradas
 always @ (reset_n,irun_setn,ialarm_read_setn,ialarm1,ialarm2,ialarm3) begin
 	end
 end
 
-reg beep_r;
-assign beep = beep_r;
 always @ (ialarm_off_on, al1_bp, al2_bp, al3_bp, cron_tmo)
 	beep_r = (ialarm_off_on & (al1_bp | al2_bp | al3_bp)) | cron_tmo;
 
 assign timer_out = cron_tmo;
 
-reg [23:0]digitos_salida;
-
-bcd_to_7seg hr_h_7_seg (
-	.bcd (digitos_salida[23:20]),
-	.segments (display1)
-);
-
-bcd_to_7seg hr_l_7_seg (
-	.bcd (digitos_salida[19:16]),
-	.segments (display2)
-);
-
-bcd_to_7seg min_h_7_seg (
-	.bcd (digitos_salida[15:12]),
-	.segments (display3)
-);
-
-bcd_to_7seg min_l_7_seg (
-	.bcd (digitos_salida[11:08]),
-	.segments (display4)
-);
-
-bcd_to_7seg sec_h_7_seg (
-	.bcd (digitos_salida[07:04]),
-	.segments (display5)
-);
-
-bcd_to_7seg sec_l_7_seg (
-	.bcd (digitos_salida[03:00]),
-	.segments (display6)
-);
-
 always @ (reset_n,irun_setn,itime_stopwn,ialarm1,ialarm2,ialarm3,tiempo_actual,tiempo_cron,tiempo_al1,tiempo_al2,tiempo_al3) begin
 	if (irun_setn == 1'b0) begin
 		if (itime_stopwn == 1'b0) digitos_salida = tiempo_cron;

ariel/scripts/dc.tcl

 # uso analizy t elaborate porque tengo modulos con parametros
-analyze -f verilog {rtl/bcd_to_7seg.v rtl/alarma.v rtl/one_sec_pulse.v rtl/cont_bcd_2_dig.v rtl/rtc.v rtl/reloj.v rtl/button_debounce.v rtl/cronometro.v rtl/button_debounce_pro.v}
+analyze -f verilog {rtl/buzzer.v rtl/bcd_to_7seg.v rtl/alarma.v rtl/one_sec_pulse.v rtl/cont_bcd_2_dig.v rtl/rtc.v rtl/reloj.v rtl/button_debounce.v rtl/cronometro.v rtl/button_debounce_pro.v}
 elaborate rtc
 # Seteo el current design
 current_design rtc
 group_path -name COMBO -from [all_inputs] -to [all_outputs]
 group_path -name clk -critical_range 2000 -weight 5
 # Sintetizo
+compile_ultra -retime -scan -no_autoungroup
 compile_ultra -retime -scan -timing -no_autoungroup
 #compile_ultra -retime -scan -timing -no_autoungroup -incremental
-#compile_ultra -retime -scan -timing
+#compile_ultra -retime -scan
 # # Verifico que no haya violaciones
 # report_constraint -all_violators
 # report_timing

ariel/scripts/rtc.con

 
 # Clock contraints
 create_clock -period 30517.578125 [get_ports clk]
-set_clock_latency -max 1000 [get_clocks clk]
-set_clock_uncertainty -setup 400 [get_clocks clk]
-set_clock_transition 100 [get_clock clk]
+set_clock_latency -max 500 [get_clocks clk]
+set_clock_uncertainty -setup 300 [get_clocks clk]
+set_clock_transition 50 [get_clock clk]
 
 # Inputs constraints
-set_input_delay -clock clk -max 15000 [all_inputs]
+set_input_delay -clock clk -max 20000 [all_inputs]
 remove_input_delay [get_ports clk]
 
 # Outputs contraints
-set_output_delay -clock clk -max 15000 [all_outputs]
-set_load 50 [all_outputs]
+set_output_delay -clock clk -max 20000 [all_outputs]
+set_load 10 [all_outputs]
 
 # PVT
 # La libreria de 90nm solo tiene las condiciones tipicas