Documentos de Académico
Documentos de Profesional
Documentos de Cultura
SecuencialesI PDF
SecuencialesI PDF
D Q Lógica D Q
clk C Combinatoria C
// FDCPE_1: Single Data Rate D Flip-Flop with Asynchronous Clear, Set and
// Clock Enable (negedge clock).
// All families.
// Xilinx HDL Language Template, version 11.1
FDCPE_1 #(
.INIT(1'b0) // Initial value of register (1'b0 or 1'b1)
) FDCPE_1_inst (
.Q(Q), // Data output
.C(C), // Clock input
.CE(CE), // Clock enable input
.CLR(CLR), // Asynchronous clear input
.D(D), // Data input
.PRE(PRE) // Asynchronous set input
);
Registros
// Listing 4.5
module reg_reset
(
input wire clk, reset, D
input wire [7:0] d,
output reg [7:0] q
);
endmodule
module free_run_shift_reg
Shift Register
#(parameter N=8)
( • En cada ciclo, desplaza hacia
input wire clk, reset,
input wire s_in, derecha (o izquierda) una
output wire s_out posición.
);
// body
// register
always @(posedge clk, posedge reset) s_in s_out
if (reset)
r_reg <= 0; clk
else
r_reg <= r_next;
// next-state logic
assign r_next = {s_in, r_reg[N-1:1]};
// output logic
assign s_out = r_reg[0];
endmodule
Shift Register
reset
s_in
r_next
Lógica de
siguiente estado
clk
r_reg
Lógica de
salida
s_out
Ejemplo: Universal Shift Register
• Carga Paralela de la
crt entrada d.
00 no_op
• Shift de una posición a la
01 Shift left
izquierda. El bit mas bajo
10 Shift right
se carga con el bit mas
11 load bajo de la entrada d.
• Shift de una posición a la
reset derecha. El bit mas alto
ctrl
se carga con el bit mas
clk
alto de la entrada d.
d q
Ejemplo: Universal Shift Register
reset
clk
Universal Shift Register: Estado
Futuro
00 nada
01 shift left
10 shift right
11 carga paralela
Universal Shift Register: elemento
de estado
r_next
reset
clk estado
r_reg
Ejemplo: Universal Shift Register
r_reg salida q
Ejemplo: Universal Shift Register
module univ_shift_reg
#(parameter N=8) // next-state logic
( always @*
input wire clk, reset, case(ctrl)
input wire [1:0] ctrl, 2'b00: r_next = r_reg; // no op
input wire [N-1:0] d, 2'b01: r_next = {r_reg[N-2:0], d[0]}; // shift left
output wire [N-1:0] q 2'b10: r_next = {d[N-1], r_reg[N-1:1]}; // shift right
); default: r_next = d; // load
endcase
//signal declaration
reg [N-1:0] r_reg, r_next; // output logic
assign q = r_reg;
// body
// register endmodule
always @(posedge clk, posedge reset)
if (reset)
r_reg <= 0;
else
r_reg <= r_next;
module free_run_bin_counter
#(parameter N=8)
(
input wire clk, reset,
output wire max_tick,
Contador Binario
output wire [N-1:0] q
);
// body
// register
always @(posedge clk, posedge reset)
if (reset)
r_reg <= 0; // {N{1b'0}} max_tick
else
r_reg <= r_next;
// next-state logic
assign r_next = r_reg + 1;
// output logic q
assign q = r_reg;
assign max_tick = (r_reg==2**N-1) ? 1'b1 : 1'b0;
endmodule
Contador Binario Universal
clk reset
syn_clr Max_tick
load
en q
up
d Min_tick
Testbench para el circuito contador
universal
// Listing 4.12
`timescale 1 ns/10 ps
Generador Generador
// The `timescale directive specifies that reset
CLK
// the simulation time unit is 1 ns and
// the simulator timestep is 10 ps
module bin_counter_tb();
// declaration
localparam T=20; // clock period UUT
reg clk, reset;
waveform
reg syn_clr, load, en, up;
reg [2:0] d;
wire max_tick, min_tick;
wire [2:0] q;
Generador
// uut instantiation
univ_bin_counter #(.N(3)) uut Otros
(.clk(clk), .reset(reset), .syn_clr(syn_clr), estímulos
.load(load), .en(en), .up(up), .d(d),
.max_tick(max_tick), .min_tick(min_tick), .q(q));
Testbench para el circuito contador
universal
• El generador de reloj
// clock
// 20 ns clock running forever se realiza con un
always @
begin always block sin lista
clk = 1'b1;
#(T/2);
de sensibilidad… se
clk = 1'b0;
#(T/2);
repite por siempre.
end
• Cronómetro
clk
0 0 0
d2
clr d1
d0
go 9 9 9
d2_reg
Tick cada 1.000.000.000
9 +1 d2_next
CLR
segundos
d1_reg
Tick cada 100.000.000
9 +1 d1_next
CLR
Décimas de segundo
d0_reg
Tick cada 10.000.000
9 +1 d0_next
Agregamos a cada registro la
señal GO
CLR
d2_reg
9
c
+1 d2_next
GO
Tick cada 500.000.000
d2_reg
clk 0..9 +1 d2_next
d1_tick
CLR
d1_next
d1_reg
clk 0..9 +1
d0_tick
CLR
d0_next
d0_reg
clk c0..9 +1
ms_tick
ms_next
ms_reg
clk c0..10000000 +1