Modelação de circuitos síncronos

(1)

73 FEUP/DEEC – Laboratório de Sistemas Digitais

Modelação de circuitos síncronos

• Como se constrói um flip-flop tipo D?

module ffd( CLK, D, Q);

input CLK; // sinal de relogio, activo na transição 0->1

input D; // entrada D

output Q; // saída Q

reg Q; // Q tem que ser declarado também como reg

always @(posedge CLK) begin

Q <= D; end endmodule

Sempre que CLK passa de 0 para 1…

Q passa a conter o valor que está em D Dentro de ‘always @(posedge…)’ as atribuições devem ser todas do tipo ‘<=‘ e não ‘=‘

Modelação de circuitos síncronos

• Um flip-flip tipo D com enable

module ffden( CLK, EN, D, Q);

input CLK, EN; // sinal de relogio e de ‘enable’

always @(posedge CLK) begin if ( EN ) Q <= D; end endmodule

Sempre que CLK passa de 0 para 1 e EN é igual a 1 a saída Q passa a conter o valor de D, caso contrário Q mantém o valor que tinha antes

(2)

Como iniciar o valor de um FFD

• Quando um flip-flop começa a trabalhar o valor

em Q é desconhecido (pode ser 1 ou 0)

• Qualquer sistema que tenha flip-flops deve ter

uma forma de impor o valor inicial das saídas Q

dos flip-flops

• Sinais de iniciação chamam-se usualmente sinais

de reset

• Um sinal de reset pode ser activo com 1 ou 0 e

pode ser síncrono ou assíncrono

Reset síncrono e assíncrono

• Reset síncrono (depende do clock)

– a acção de reset ocorre apenas quando o sinal

de relógio tem a sua transição activa

• Reset assíncrono (não depende do clock)

– A acção de reset ocorre sempre que o sinal de

reset é colocado no seu nível activo

– O reset assíncrono é uma entrada própria do FF

Q D CLK RST D CLK

(3)

Modelação de circuitos síncronos

• FFD com enable e reset (síncrono)

module ffdenrst( CLK, EN, RST, D, Q);

input CLK, EN, RST; // relogio, ‘enable’ e ‘reset’ (activo a 1)

always @(posedge CLK) begin if ( RST ) Q <= 1’b0; else if ( EN ) Q <= D; end endmodule

Se RST é 1, Q é colocado com zero (reset) (mas este valor não tem que ser zero!)

Senão, funciona como o FFD com enable

Modelação de circuitos síncronos

• FFD com enable e reset (assíncrono)

module ffdenrsta( CLK, EN, RST, D, Q);

always @(posedge CLK or posedge RST) begin if ( RST ) Q <= 1’b0; else if ( EN ) Q <= D; end endmodule

Quando RST passa de 0 para 1, Q é colocado com zero (reset)

(4)

Um registo de 8 bits: 8 FFs tipo D

• com enable e reset (assíncrono)

module reg8benrsta( CLK, EN, RST, D, Q);

input [7:0] D; // entrada D com 8 bits

output [7:0] Q; // saída Q com 8 bits...

reg [7:0] Q; // ... Que também é um ‘reg’

always @(posedge CLK or posedge RST) begin if ( RST ) Q <= 8’b0000_0000; else if ( EN ) Q <= D; end endmodule

Quando RST passa de 0 para 1, Q é colocado com o valor inicial (reset)

Senão, funciona como o FFD com enable

Um contador de 8 bits

• É um registo de 8 bits em que D = Q + 1

module conta8b( CLK, RST, Q);

input CLK, RST; // relogio e ‘reset’ (activo a 1)

output [7:0] Q; // saída Q

reg [7:0] Q; // Q tem que ser declarado também como reg

wire [7:0] D; // representa o ‘fio’ ligado à entrada D do reg.

assign D = Q + 1; // a entrada D do registo é sempre igual a Q+1

always @(posedge CLK or posedge RST) // este bloco é um registo

begin // de 8 bits com reset

if ( RST ) Q <= 8’b0000_0000; else Q <= D; end endmodule Q D CLK RST CLK + 1 8 RST Q 8

(5)

Um contador de 8 bits com ‘load’

module conta8bld( CLK, RST, LD, E, Q);

input CLK, RST, LD; // relogio, ‘reset’ e ‘load’

input [7:0] E; // entrada de 8 bits para carregar o contador

assign D = LD ? E : Q + 1; // se LD==1 então D=E senão D=Q+1

if ( RST ) Q <= 8’b0000_0000; else Q <= D; end endmodule Q D CLK RST CLK + 1 8 RST Q 8 E LD 1 0 8 82 FEUP/DEEC – Laboratório de Sistemas Digitais

Um contador ‘up/down’ de 8 bits

module conta8bupdown( CLK, RST, LD, E, UD, Q);

input CLK, RST, LD, UD; // relogio, ‘reset’, ‘load’ e UP/DOWN

input [7:0] E; // entrada de 8 bits para carregar o contador

assign D = LD ? E : ( UD ? Q + 1 : Q – 1); // UD=1 conta para cima

if ( RST ) Q <= 8’b0000_0000; else Q <= D; end endmodule Q D CLK RST CLK +/-1 8 RST Q 8 E LD 1 0 8 UD addsub

(6)

Modelo geral de uma máquina de estados

(modelo de Moore)

• Registo de estado

– Entradas D (próximo estado) e saídas Q (estado presente)

• Circuito combinacional

que define o próximo estado

– Depende de Q e das entradas E e produz D

• Circuito combinacional

que produz as saídas Z

– Só depende de Q (máquina de Moore)

registo de estado Z E CLK D (próximo estado) reset (estado presente) Q 84 FEUP/DEEC – Laboratório de Sistemas Digitais

module fsm( CLK, RST, E, Z);

input CLK, RST; // relogio e ‘reset’

input E; // entrada E

output Z; // saída Z

reg [1:0] STATE; // registo de estado

reg [1:0] NEXTSTATE; // proximo estado

always @(posedge CLK or posedge RST) // registo de estado com reset begin if ( RST ) STATE <= 2’b00; else STATE <= NEXTSTATE; end

always @* // define o circuito lógico que produz NEXTSTATE case ( STATE )

// define o valor de NEXTSTATE em função de STATE e E endcase

always @* // define o circuito lógico que produz a saída Z case( STATE)

// define o valor da saída Z em função do estado actual STATE endcase

(7)

INI S1 S2 X=1 X=1 X=0 X=0 Y=0 Y=0 Y=1

Exemplo de uma máquina de estados em

Verilog (modelo de Moore)

CLK X Y

• 3 estados (INI é o estado inicial)

– Bastam 2 bits para codificar o estado

• Uma entrada X

• Uma saída Y que só depende do estado presente

– modelo de máquina de estados de Moore

module fsm( CLK, RST, X, Y);

input X; // entrada X

output Y; reg Y; // saída Y

parameter INI = 2’b00, // definição de constantes que representam

S1 = 2’b01, // os nomes simbólicos dos estados

S2 = 2’b11;

always @(posedge CLK or posedge RST) // registo de estado begin // com reset assíncrono

if ( RST ) // define o estado inicial como INI

STATE <= INI; else STATE <= NEXTSTATE;

end

always @* // circuito lógico que produz NEXTSTATE case ( STATE )

INI: if ( X == 1’b0 ) NEXTSTATE = INI; else NEXTSTATE = S1; S1 : if ( X ) NEXTSTATE = S1; else NEXTSTATE = S2;

S2 : NEXTSTATE = INI;

endcase

always @* // circuito lógico que produz a saída Y: só depende de STATE case( STATE) INI: Y = 0; S1 : Y = 0; S2 : Y = 1; endcase endmodule

(8)

output Y; // saída Y

S2 = 2’b11;

...

assign Y = ( STATE == S2 ); // Y é 1 quando STATE for igual a S2

endmodule

Outra forma de definir o valor de Y

• Y vale 1 quando o estado presente é S2

INI S1 S2 X=1 X=1 X=0 X=0 Y=0 Y=0 Y=1

Como acrescentar uma entrada ‘restart’

(reset síncrono)

CLK X Y RESTART=1 RESTART=1 RESTART

(9)

module fsm( CLK, RST, RESTART, X, Y); input CLK, RST; // relogio e ‘reset’

input X, RESTART; // entrada X e RESTART

S2 = 2’b11;

always @(posedge CLK or posedge RST) // registo de estado begin // com reset assíncrono

if ( RST ) // define o estado inicial como INI

STATE <= INI; else STATE <= NEXTSTATE;

end

always @* // circuito lógico que produz NEXTSTATE if ( RESTART ) NEXTSTATE = INI;

else

case ( STATE )

INI: if ( X == 1’b0 ) NEXTSTATE = INI; else NEXTSTATE = S1; S1 : if ( X ) NEXTSTATE = S1; else NEXTSTATE = S2;

S2 : NEXTSTATE = INI;

endcase

always @* // circuito lógico que produz a saída Y ...

endmodule

Modelo geral de uma máquina de estados

(modelo de Mealy)

• Diferença para o modelo de Moore:

• O

circuito combinacional

que produz as saídas Z

– depende do estado presente (Q) e das entradas E

registo de estado Z E CLK D (próximo estado) reset (estado presente) Q Z também depende de E

(10)

INI S1 S2 X=1, Y=0 X=1, Y=0 X=0, Y=0 X=0, Y=1

Exemplo de uma máquina de estados em

Verilog (modelo de Mealy)

CLK X Y

• Uma entrada X

• Uma saída Y que depende do estado presente e de X

– modelo de máquina de estados de Mealy

• Em cada estado, o valor de Y é determinado pelas

mesmas condições que definem o valor do próximo estado

X=0, Y=0

X=1, Y=1

S2 = 2’b11;

// registo de estado é igual aos exemplos anteriores

always @* // circuito lógico que produz NEXTSTATE case ( STATE )

INI: if ( X ) NEXTSTATE = S1; else NEXTSTATE = INI; S1 : if ( X ) NEXTSTATE = S1; else NEXTSTATE = S2; S2 : if ( X ) NEXTSTATE = INI; else NEXTSTATE = S2;

endcase

always @* // circuito lógico que produz a saída Y: depende de STATE e de X case( STATE) INI: Y = 0; S1 : if ( X ) Y = 0; else Y = 1; S2 : if ( X ) Y = 1; else Y = 0; endcase endmodule

(11)

Outra forma de definir as saídas em

máquinas de estados de Mealy

• Em cada estado, as saídas dependem do valor das entradas

• As condições que determinam as saídas são geralmente as

mesmas que determinam o próximo estado

– Não é necessário escrever duas vezes a instrução ‘

case

’

• Os dois blocos

always

(próximo estado e saídas) podem ser

combinados num único

always @* // circuito lógico que produz NEXTSTATE e a saída Y case ( STATE ) INI: if ( X ) begin NEXTSTATE = S1; Y = 0; end else begin NEXTSTATE = INI; Y = 0; end S1 : if ( X ) begin NEXTSTATE = S1; Y = 0; end else begin NEXTSTATE = S2; Y = 1; end S2 : if ( X ) begin NEXTSTATE = INI; Y = 1; end else begin NEXTSTATE = S2; Y = 0; end endcase