1

SZEKVENCIÁLIS LOGIKAI MODULOK TERVEZÉSI LEHETŐSÉGEI VERILOG NYELVEN

Felhasználói primitívek (UDP)Viselkedési leírás időzítésvezérlésselKönyvtári elemek használataMeglévő modulok használata

Szekvenciális UDP-kÉlvezérelt Flip-flop-okLatch-ekExplicit vezérlők (FSM-ek)Implicit vezérlők (FSM-ek)Mealy-Moore automaták

2

SZEKVENCIÁLIS UDP-k SZINTÉZISE

A nyelv nem tartalmaz beépített szekvenciális elemeket, viszont támogatja a felhasználó által defininiált szekvenciális primitívek használatát.

A szekvenciális UDP-k csak egyetlen órajel portot tartalmazhatnak. A szintézis eszközök felismerik a primitív adat, esetleges engedélyezés, órajel és az aszinkron set, reset vezérlő bemeneteit. A szinkron vezérlő bemenetek nem mindig alkalmazhatók.

3

PÉLDA JK - FLIP FLOP SZINTÉZISÉRE

Ha például egy technológiai könyvtár nem tartalmaz J-K flip-flop-ot, akkor a szintézis program az alábbi UDP leírás alapján a szükséges kombinációs

logika és egy D flip-flop felhasználásával valósítja meg azt.

model jk_flop (q, clk, j, k, clr); output q; input clk, j, k, clr; jk_udp (q, clk, j, k, clr); endmodule primitive jk_udp (q, clk, j, k, clr); output q; input clk, j, k, clr; reg q;

table // clk, j k clr q next_q ? ? ? 0 : ? : 0; f 0 0 1 : ? : -; f 0 1 1 : ? : 0; f 1 0 1 : ? : 1; f 1 1 1 : 0 : 1; f 1 1 1 : 1 : 0; r ? ? ? : ? : -; ? * ? ? : ? : -; ? ? * ? : ? : -; ? ? ? * : ? : -; endtable endprimitive

4

SZEKVENCIÁLIS LOGIKÁK SZINTÉZISE

UDP-k LATCH-ek ÉLVEZÉRELT FLIP-FLOP-ok VÉGES ÁLLAPOTÚ VEZÉRLŐK (EXPLICIT és IMPLICIT) MEALY-MOORE AUTOMATÁK

5

LATCH-ek

SZABÁLYOK • Minden olyan viselkedési leírás, amelynek végrehajtása során a

változók nem minden esetben kapnak új értéket, a szintézis eszközök értelmezése szerint latch tároló regiszterek alkalmazását teszi szükségessé.

• A viselkedési leírás elágazási feltételjele lesz a latch engedélyező jele. • Latch-ek alkalmazására csak a nem teljesen specifikált ’case’ és más

feltételes utasítások (if, ? :) esetében kerül sor. • Az egyéb utasítások vagy közvetlen kapuszintű leírások alapján

keletkező visszacsatolt hurkok realizálására nem alkalmaznak latch-eket.

6

PÉLDA ASZINKRON LATCH SZINTÉZISÉRE

module asynch_latch (latch_out, latch_in, set, clear, enable); input latch_in, enable, set, clear; output latch_out; reg latch_out; always @ (enable or set or clear) case ({enable, set, clear}) 3'b000: assign latch_out = latch_in; // Transparens mód 3'b110: assign latch_out = 1'b1; 3'b010: assign latch_out = 1'b1; 3'b101: assign latch_out = 1'b0; 3'b001: assign latch_out = 1'b0; default: deassign latch_out; // Korábbi érték tartása endcase endmodule

7

LATCH SZINTÉZIS AZ "assign ... deassign" UTASÍTÁSSAL

LEÍRÁSI STÍLUS: assign/deassign UTASÍTÁS

module latch_syn1 (data_out, data_in, latch_enable); input [7:0] data_in; output [7:0] data_out; input latch_enable; reg [7:0] data_out; always @ (latch_enable) if (latch_enable) assign data_out = data_in; else

latch_enable

data_outputdata_input

8 8

deassign data_out; // Korábbi érték tartása. endmodule

8

LATCH SZINTÉZIS NEM TELJESEN DEFINIÁLT ELÁGAZÁS UTASÍTÁSSAL

LEÍRÁSI STÍLUS: NEM TELJESEN SPECIFIKÁLT ELÁGAZÁS UTASÍTÁS

module latch_syn2 (data_out, data_in, latch_enable); input [7:0] data_in; output [7:0] data_out; input latch_enable; reg [7:0] data_out;

always @ (latch_enable or data_in) if (latch_enable) data_out = data_in; endmodule

9

SZEKVENCIÁLIS LOGIKÁK SZINTÉZISE

UDP-k LATCH-ek ÉLVEZÉRELT FLIP-FLOP-ok VÉGES ÁLLAPOTÚ VEZÉRLŐK (EXPLICIT és IMPLICIT) MEALY-MOORE AUTOMATÁK

10

FLIP-FLOP-ok

SZABÁLYOK

A szintézis eszközök mindazokban az esetekben, amikor egy ’reg’ típusú változóra történik értékadás egy viselkedési leírásban élvezérelt eseménykifejezéssel, a változót egy flip-flop-al realizálják.

PÉLDA

module data_swap (data_a, data_b, clk) output data_a, data_b; input clk; reg data_a, data_b; always @ (posedge clk) begin // esetleges egyéb utasítások data_b <= data_a; data_a <= data_b; end endmodule;

11

FLIP-FLOP-ok FELISMERÉSE

ÁLTALÁNOS SZABÁLY: A változót a szintézis program flip-flop-ként realizálja, ha az értékadás egy más jel élváltásával szinkron módon történik.

R

QD

R

QD

R

QD

R

QD

Data_out[3] Data_out[2] Data_out[1] Data_out[0]

Data_in[0]Data_in[1]Data_in[2]Data_in[3]

reset

clock

module D_reg4 (Data_in, clock, reset, Data_out); input [3:0] Data_in; input clock, reset; output [3:0] Data_out; reg [3:0] Data_out;

always @ (posedge reset or posedge clock) begin if (reset == 1’b1) Data_out <= 4’b0; else Data_out <= Data_in; end endmodule

12

PÉLDA JK FLIP-FLOP SZINTÉZISÉRE (1. verzió)

module jk_flop_1 (j, k, rst, clock, q, qb); input j, k, rst, clock; output q, qb; reg q; assign qb = ~q; //Invertált kimenet always @ (posedge rst or posedge clock) begin if (rst == 1’b1) q:= 1’b0; else //Aszinkron reset if ((j == 1’b0 && k == 1’b0) q = q; else //Tartás if ((j == 1’b0 && k == 1’b1) q = 1’b0; else //Törlés if ((j == 1’b1 && k == 1’b0) q = 1’b1; else //Beírás if ((j == 1’b1 && k == 1’b1) q = ~q; //Invertálás end endmodule

j

k

q

qb

clk

rst

jk_flop

13

PÉLDA JK FLIP-FLOP SZINTÉZISÉRE (2. verzió)

module jk_flop_2 (j, k, clock, q, qb); input j, k, clock; output q, qb; reg q;

j

k

q

qb

clk

jk_flop

assign qb = ~q; always @ (posedge clock) begin case {j, k} 2’b01: q = 1’b0; 2’b10: q = 1’b1’; 2’b11: q = ~q; 2’b00: q = q; endcase; end endmodule

14

A REGISZTERES LOGIKÁK SZNTÉZISÉNEK SZABÁLYAI

A KOMBINÁCIÓS LOGIKA KIMENETE REGISZTERES LESZ (AZ ÉRTÉKET EGY

FLIP-FLOP TÁROLJA), HA VISELKEDÉSI LEÍRÁSBAN AZ ESEMÉNY VEZÉRLÉS ÉLÉRZÉKENY MŰKÖDÉST ÍR ELŐ.

PÉLDA

module reg_and (a, b, c, clk, y); input a, b, c, clk; output y; reg y; always @ (posedge clk) begin y <= a & b & c; end endmodule

a

y

clk

d_flop

cb

15

PÉLDA REGISZTERES KIMENETŰ KOMBINÁCIÓS LOGIKA SZINTÉZISÉRE

A kombinációs logika, ha egy szinkron viselkedési leíráson belül definiáljuk, akkor szintézis során regiszteres kimenetet kap.

PÉLDA

ba

select

y

cd

8

8

8

8

clock

8

module mux_reg (a, b, c, d, y, select, clock); input [7:0] a, b, c, d; output [7:0] y;

input [1:0] select; reg [7:0] y; always @ (posedge clock) case (select) 0: y <= a; // A nem-blokkoló 1: y <= b; // értékadás itt 2: y <= c; // azonos a sima 3: y <= d; // = jel hatásával default y <= 8'bx; endcase endmodule

16

MEGFIGYELÉS

A szintézis során generált hardver mérete nem feltétlenül arányos a forráskód méretével!

always @ (posedge clock) begin data_register <= data_bus; end

Az értékadásban szereplő data_register lehet akár egy bites, de akár 32 bites regiszter is.

17

SHIFT REGISZTER SZINTÉZISE

R

QD

R

QD

R

QD

R

QDData_outData_in

reset

clock

module Shift_reg4 (Data_out, Data_in, clock, reset); input Data_in, clock, reset; output Data_out; reg [3:0] Data_reg; assign Data_out = Data_reg[0];

always @ (posedge reset or negedge clock) begin if (reset == 1’b1) Data_reg <= 4’b0; else Data_reg <= {Data_in, Data_reg[3:1]}; end endmodule Megjegyzés: A példában a regiszter változó a kifejezés jobb oldalán a láncolás műveletben is szerepel, a szinkron értékadást megelőzően. Ezért a szintézis flip-flop-ot generál.

18

PÁRHUZAMOS TÖLTÉSŰ SHIFT REGISTER

R

QD

R

QD

R

QD

R

QD

Data_out[3] Data_out[2] Data_out[1] Data_out[0]

Data_in[0]Data_in[1]Data_in[2]Data_in[3]

reset

clock

load

mux mux muxmux

module Par_load_reg4 (Data_out, Data_in, load, reset, clock);

input [3:0] Data_in; input load, reset, clock; output [3:0] Data_out; reg [3:0] Data_out;

always @ (posedge reset or posedge clock) begin if (reset == 1’b1) Data_out = 4’b0; else if (load == 1’b1) Data_out <= Data_in; end endmodule

19

PÉLDA: BARREL SHIFTER (BITFORGATÓ)

module barrel_shifter (Data_out, Data_in, load, reset, clock); input [7:0] Data_in; input load, reset, clock; output [7:0] Data_out; reg [7:0] Data_out; always @ (posedge reset or posedge clock) begin if (reset == 1’b1) Data_out <= 8’b0; else if (load == 1’b1) Data_out <= Data_in; else Data_out <= {Data_out[6:0], Data_out[7]}; end endmodule

6 5 4 3 2 1 07

1 0 0 0 1 1 01

6 5 4 3 2 1 07

1 0 0 0 1 1 0 1

20

ASZINKRON SZÁMLÁLÓ

R

QT

R

QT

R

QT

R

QT

count(1)

reset

clock

count(0) count(3)count(2)toggle

module ripple_counter (clock, toggle, reset, count); // Aszinkron számláló input clock, toggle, reset; output [3:0] count; reg [3:0] count; always @ (posedge reset or posedge clock) if (reset == 1’b1) count[0] <= 1’b0; else if (toggle == 1’b1) count[0] <= ~count[0]; always @ (posedge reset or negedge count[0]) if (reset == 1’b1) count[1] <= 1’b0; else if (toggle == 1’b1) count[1] <= ~count[1];

always @ (posedge reset or negedge count[1]) if (reset == 1’b1) count[2] <= 1’b0; else if (toggle == 1’b1) count[2] <= ~count[2]; always @ (posedge reset or negedge count[2]) if (reset == 1’b1) count[3] <= 1’b0; else if (toggle == 1’b1) count[3] <= ~count[3]; endmodule Nem ajánlott szintézishez!!

21

GYŰRŰS (JOHNSON) SZÁMLÁLÓ

module ring_counter (enable, reset, clock, count); input enable, reset, clock; output [7:0] count; reg [7:0] count; always @ (posedge reset or posedge clock) if (reset == 1’b1) count <= 8’b00000001; else if (enable == 1’b1) count <= {count[6:0], count[7]}; endmodule

0 0 0 0 0 0 1

0 0 0 0 0 01

0 0 0 0 001

0 0 0 0001

0 0 1 0 0 0 0

0 1 0 0 0 0 0

01 0 0 0 0 0

count [7:0]

22

SZINKRON TÖLTHETŐ, ELŐRE/HÁTRA SZÁMLÁLÓ

module up_down_counter (clk, reset, load, count_up, count_en, Data_in, Count); input clk, reset, load, count_up, count_en; input [3:0] Data_in; output [3:0] Count; reg [3:0] Count; always @ (posedge reset or posedge clk) if (reset == 1’b1) Count = 4’b0; else if (load == 1’b1) Count = Data_in; else if (count_en == 1’b1) begin if (count_up == 1’b1) Count = Count +1; else Count = Count –1; end endmodule

clk

ldrstcnt

u/d

4

D_in

4Count

23

SOROS SHIFT REGISZTER (KÉSLELTETŐ) SZINTÉZISE

Shift_in

reset

clock

reg_a reg_b reg_c reg_d

R

QD

R

QD

R

QD

R

QD

always @ (posedge clock) begin: Shift_register_1 if (reset == 1’b1) begin reg_a <= 1’b0; reg_b <= 1’b0; reg_c <= 1’b0; reg_d <= 1’b0; end

else begin reg_a <= Shift_in; reg_b <= reg_a; reg_c <= reg_b; reg_d <= reg_c; end

A SZINTÉZIS EREDMÉNE: Shift regiszter aszinkron törlésse.

Megjegyzés: A “=” értékadás a “<=” helyett hibás működést eredményez.

24

A REGISZTERES LOGIKÁK ÁLTALÁNOS SZABÁLYAI

always @ (posedge reset or posedge clock) begin if (reset == 1’b1) begin sig_a <= ‘0’; sig_b <= ‘0’; sig_c <= ‘0’; sig_d <= ‘0’; pulse <= 1’b0; end

shift_input

reset

sig_a sig_b sig_c sig_d

clock

pulse

else begin sig_a <= shift_input; sig_b <= sig_a; sig_c <= sig_b; sig_d <= sig_c; pulse <= (~ sig_a) & sig_b; end end

Az élérzékeny viselkedési leíráson belüli szinkron értékadások flip-flop vagy latch szintézisét eredményezik.

25

NEM KÍVÁNT REGISZTEREK ELKERÜLÉSE

Mindazok az értékadások, amelyek a viselkedési blokkokon kívül vannak, vagy olyan viselkedési blokkban, amely nem használ szinkronizáló eseményvezérlést, tisztán kombinációs logikát eredményeznek. always @ (posedge reset or posedge clock) begin if (reset == 1’b1) begin sig_a <= 1’b0; sig_b <= 1’b0; sig_c <= 1’b0; sig_d <= 1’b0; end

shift_input

reset

sig_a sig_b sig_c sig_d

clockpulse

else begin sig_a <= shift_input; sig_b <= sig_a; sig_c <= sig_b; sig_d <= sig_c; end end assign pulse = (~ sig_b) & sig_c;

Megjegyzés: A pulzust kombinációs logika realizálja. Az időzítési pozíció megőrzésé-hez a bemenőjeleket módosítani kellett. A kimeneti jel késleltetése nagyobb!!!

26

SZEKVENCIÁLIS LOGIKÁK SZINTÉZISE

UDP-k LATCH-ek ÉL-VEZÉRELT FLIP-FLOP-ok VÉGES ÁLLAPOTÚ VEZÉRLŐK (EXPLICIT és IMPLICIT) MEALY-MOORE AUTOMATÁK

27

SZINKRON ÁLLAPOTVEZÉRLŐK

Input (n)Next

State(n)

State(n)

Output(n)

Reg_Output(n)NextStateLogic

OutputLogic

OutputRegister

StateRegister

Szinkron állapotvezérlő

28

SZINKRON ÁLLAPOTVEZÉRLŐ (2. verzió)

Input (n)Next

State(n)

State(n)Output(n)

Reg_Output(n)

NextStateLogic

OutputLogic

OutputRegister

StateRegister

Szinkron állapotvezérlő késleltetett kimeneti visszacsatolással

DataRegisters

29

MEALY ÉS MOORE AUTOMATÁK

OutputLogicInputs

Outputs

StateStateRegister

Next StateLogic

MEALY AUTOMATA Next_State(t) = g(State(t), Input(t)) Output(t) = h(state(t), Input(t)) MOORE AUTOMATA Next_State(t) = g(State(t), Input(t)) Output(t) = h(state(t))

30

VÉGES ÁLLAPOTÚ VEZÉRLŐK (FSM) IMPLEMENTÁCIÓS LEHETŐSÉGEI

A SZINTÉZIS ESZKÖZÖK KÉTFÉLE FSM LEÍRÁST KÉPESEK KEZELNI: EXPLICIT FSM

• Az állapotok sorrendje specifikált. • Állapotregiszter tartja az állapotok kódolt reprezentációját. • Explicit állapotátmenet előírások vezérlik az állapotsorrendet.

IMPLICIT FSM

• Az állapotok sorrendje specifikált. • Nincs egyértelműen definiált állapotregiszter. • A viselkedési leírás eseményei határozzák meg az állapotsorrendet.

31

EXPLICIT FSM DEFINÍCIÓ TIPIKUS FORMÁJA

module mod_name ( …); input … ; output … ; parameter size = … ; reg [size-1 ;0] state, next_state;

`define state_0 2’b00 `define state_1 2’b01 …

assign the_outputs = … // a bemenetek és az állapot függvényében assign next_state = … // a bemenetek és az állapot függvényében /* always @ (state or inputs) //A következő állapot előírása begin //viselkedési leírással // next_state dekódolása case vagy if utasítással end */ always @ (negedge reset or posedge clk) begin if (reset == 1’b0) state = state_0; else state <= next_state; endmodule

32

PÉLDA: EGYSZERŰ SEBESSÉG VEZÉRLŐ

low

highmedium

stopped

brake = 1 accelerator = 1brake =0

brake = 1brake = 1

accelerator = 1brake = 0

accelerator = 1brake = 0

accelerator = 1brake = 0

brake = 1accelerator

brakeclock

speed

33

SEBESSÉGVEZÉRLŐ, MINT EXPLICIT FSM

module speed_machine_1 (clock, accelerator, brake, speed); // Explicit FSM, szinkron állapot értékadás, a bemenetek és az állapot teljes dekódolásával input clock, accelerator, brake; output [1:0] speed; reg [1:0] state, next_state; `define stopped 2'b00 `define low 2'b01 `define medium 2'b10 `define high 2'b11 always @ (posedge clock) state <= next_state; always @ (state or accelerator or brake) if (brake == 1’b1) case (state) `stopped: next_state <= `stopped; `low: next_state <= `stopped; `medium: next_state <= `low; `high: next_state <= `medium; default: next_state <= `stopped; endcase

else if (accelerator == 1’b1) case (state) `stopped: next_state <= `low; `low: next_state <= `medium; `medium: next_state <= `high; `high: next_state <= `high; default: next_state <= `stopped; endcase else next_state <= state; assign speed = state; endmodule

MEGJEGYZÉSEK: Biztonsági autó. 1. A fékpedál erősebb hatású. 2. Bármely illegális állapotból vészfékkel leáll. 3. Inaktív pedálok esetén tartja a sebességet. A next_state változó nem lesz regiszter!!

34

SEBESSÉGVEZÉRLŐ, MINT IMPLICIT FSM

module speed_machine_2 (clock, accelerator, brake, speed); // Implicit FSM, a bemenetek és az állapot dekódolása a szinkron viselkedésen belül történik // A modell nem tartalmaz explicit állapotregisztert, jelen esetben a kimenet implikálja az állapotot input clock, accelerator, brake; output [1:0] speed; reg [1:0] speed; `define stopped 2’b00 `define low 2'b01 `define medium 2'b10 `define high 2'b11 always @ (posedge clock) if (brake == 1’b1) case (speed) `stopped: speed <= `stopped; `low speed <= `stopped; `medium: speed <= `low; `high: speed <= `medium; default: speed <= `stopped; endcase

else if (accelerator == 1’b1) case (speed) `stopped: speed <= `low; `low: speed <= `medium; `medium: speed <= `high; `high: speed <= `high; default: speed <= `stopped; endcase else speed <= speed; endmodule

MEGJEGYZÉSEK: Az előző megjegyzések

érvényesek

35

SEBESSÉGVEZÉRLŐ SZINTÉZIS, TOVÁBBI ALTERNATÍVA

module speed_machine_3 (clock, accelerator, brake, speed); // Implicit FSM, az állapot teljes dekódolásával, majd a bemenetek (prioritásos) kiértékelésével. // A modell nem tartalmaz explicit állapotregisztert, jelen esetben a kimenet implikálja az állapotot input clock, accelerator, brake; output [1:0] speed; reg [1:0] speed; `define stopped 2’b00 `define low 2'b01 `define medium 2'b10 `define high 2'b11

always @ (posedge clock) case (speed ) `stopped: if (brake == 1’b1) speed <= `stopped; else if (accelerator == 1’b1) speed <= `low; `low: if (brake == 1’b1) speed <= `slow; else if (accelerator = 1’b1) speed <= `medium; `medium: if (brake == 1’b1) speed <= `low; else if (accelerator == 1’b1) speed <= `high; `high: if (brake == 1’b1) speed <= `medium; default: speed <= `stopped; endcase endmodule

36

EXPLICIT VÉGES ÁLLAPOTÚ VEZÉRLŐK (FSM)

• A tervező egyértelműen megadja az állapotok sorrendjének leírását. • Egy deklarált állapotváltozó (’reg’ típus) tartalmazza az állapotok kódolt

reprezentációját. • Explicit értékadások biztosítják az állapotregiszter módosítását, az

állapot átmeneti gráf (STG) előírásainak megfelelően. • Az állapotregiszter minden lehetséges értékadása előre ismert és

specifikált. • A kombinációs logika az állapotkódolásnak függvényében

optimalizálható. • Az állapot értékadások a követelményeknek megfelelően optimálisan

kódolhatóak. • Tipikus nyelvi konstrukciók: teljes ’case’ utasítás az állapotátmenetekre. • A modell külön logikát tartalmaz az állapotátmenetekhez és a kimenethez.

37

AZ EXPLICIT FSM SZINTÉZISÉNEK KRITÉRIUMAI

• A viselkedési leírás csak egyetlen időzítés vezérlési kifejezést

tartalmazhat. • Az egyik viselkedési modul regiszterét egyértelműen állapotregiszterként

kell deklarálni. • A vezérlőben csak egyetlen állapotregiszter deklarálható. • Az állapotregiszter minden értékadása a teljes regiszterre vonatkozzon.

(Egyes bitjeinek vagy bitcsoportoknak külön nem adhatunk értéket). • Az állapotregiszter értékadásokban csak konstans kifejezések, vagy

olyan változók szerepelhetnek, amelyek statikus kiértékelése után konstans értékre vezetnek.

state_reg = data; // Nem legális state_reg = state_reg + 1; // Legális

38

EXPLICIT FSM LOGIKÁK TÍPUSAI

• KÖVETKEZŐ ÁLLAPOT LOGIKA, ÁLLAPOTÁTMENET

MEGHATÁROZÁSA next_state = mem_op ? (read ? `reading : `writing) : `start_state; next_state = state + 1; next_state = state << 2; • KIMENETI DEKÓDER LOGIKA, ADATMŰVELETEK MEGHATÁROZÁSA if (state == `start_state && mem_op && !read) internal_bus <= data; • PÉLDÁK ÁLLAPOTÁTMENET ÉRTÉKADÁSRA @ (posedge clk) state = `start_state; @ (posedge clk1) state = next_state;

39

@ (posedge clk2) state = state + 1;

40

KOMBINÁCIÓS LOGIKAI MODULOK MEGVALÓ-SÍTÁSI LEHETŐSÉGEI EXPLICIT FSM-EKBEN

AZ EXPLICIT FSM-EKBEN A KOMBINÁCIÓS LOGIKAI MODULOK MODELLEZHETŐK:

• KOMBINÁCIÓS BLOKKOKKAL • FÜGGVÉNNYEKKELL (FUNCTION) • FOLYTONOS ÉRTÉKADÁSSAL (CONT. ASSIGN.) • KÜLSŐ MODULOKKAL (A MODULHATÁROKAT A

SZINTÉZIS NEM FELTÉTLENÜL ŐRZI MEG) A következő állapotot meghatározó, a felsorolt módokon megadott feltételes értékadásoknak mindig teljesen specifikáltaknak kell lenniük.

41

MEALY FSM – BITSOROZAT DETEKTOR, SZINKRON KIMENET

Felismer két egymást követő 0 vagy 1 bitet a soros bitfolyamban.

SequenceDetector

in_bit out_bit

module seq_det_mealy_1 (clock, in_bit, out_bit); input clock, in_bit; output out_bit; reg [1:0] state_reg; reg out_bit;

State0

State1

State2

1 / 0

Input_bitOutput_bit

0 / 0

1 / 0

0 / 1 1 / 1

0 / 0

42

MEALY FSM - SZINKRON KIMENET

State

0

State1

State2

1 / 0

Input_bitOutput_bit

0 / 0

1 / 0

0 / 1 1 / 1

0 / 0

always @ (posedge clock) case (state_reg) 2'b00 : if (in_bit ==0) begin state_reg = 2'b01; out_bit = 0; end else if (in_bit ==1) begin state_reg = 2'b10; out_bit = 0; end 2'b01 : if (in_bit ==0) begin state_reg = 2'b01; out_bit = 1; end else if (in_bit ==1) begin state_reg = 2'b10; out_bit = 0; end 2'b10 : if (in_bit ==0) begin state_reg = 2'b01; out_bit = 0; end else if (in_bit ==1) begin state_reg = 2'b10; out_bit = 1; end default: begin state_reg = 2'b00; out_bit = 0; end endcase endmodule Megjegyzés: A kimenet regiszteres, azaz szinkron lesz.

43

MEALY FSM - BITSOROZAT DETEKTOR, ASZINKRON KIMENET (1. verzió)

Felismer két egymást követő 0 vagy 1 bitet a soros bitfolyamban.

SequenceDetector

in_bit out_bit

module seq_det_mealy_2 (clock, in_bit, out_bit); input clock, in_bit; output out_bit; reg [1:0] state_reg; reg [1:0] next_state; reg out_bit;

State0

State1

State2

1 / 0

Input_bitOutput_bit

0 / 0

1 / 0

0 / 1 1 / 1

0 / 0

44

MEALY FSM – ASZINKRON KIMENET (1. verzió)

always @ (posedge clock) state_reg = next_state;

State0

State1

State2

1 / 0

Input_bitOutput_bit

0 / 0

1 / 0

0 / 1 1 / 1

0 / 0

always @ (state_reg or in_bit) // Következő állapot és kimeneti logika case (state_reg) 2'b00 : if (in_bit ==0) begin next_state = 2'b01; out_bit = 0; end else if (in_bit ==1) begin next_state = 2'b10; out_bit = 0; end 2'b01 : if (in_bit ==0) begin next_state = 2'b01; out_bit = 1; end else if (in_bit ==1) begin next_state = 2'b10; out_bit = 0; end 2'b10 : if (in_bit ==0) begin next_state = 2'b01; out_bit = 0; end else if (in_bit ==1) begin next_state = 2'b10; out_bit = 1; end default: next_state = 2’b00; out_bit = 0; endcase endmodule Megjegyzés: A kimenet nem regiszteres.

45

MEALY FSM - BITSOROZAT DETEKTOR, ASZINKRON KIMENET (2. verzió)

Felismer két egymást követő 0 vagy 1 bitet a soros bitfolyamban.

SequenceDetector

in_bit out_bit

module seq_det_mealy_3 (clock, in_bit, out_bit); input clock, in_bit; output out_bit; reg [1:0] state_reg;

State

0

State1

State2

1 / 0

Input_bitOutput_bit

0 / 0

1 / 0

0 / 1 1 / 1

0 / 0

46

MEALY FSM - ASZINKRON KIMENET (2. verzió) always @ (posedge clock) state_reg = next_state;

State0

State1

State2

1 / 0

Input_bitOutput_bit

0 / 0

1 / 0

0 / 1 1 / 1

0 / 0

// Következő állapot és kimeneti logika assign next_state[1] = ((!state_reg[1]) & (!state_reg[0]) & ( in_bit)) | (( state_reg[1]) & (!state_reg[0]) & ( in_bit)) assign next_state[0] = ((!state_reg[1]) & (!state_reg[0]) & (!in_bit)) | ((!state_reg[1]) & ( state_reg[0]) & (!in_bit)) assign out_bit = ((!state_reg[1]) & ( state_reg[0]) & (!in_bit)) | (( state_reg[1]) & !state_reg[0] & (in_bit)); endmodule

47

MOORE FSM - BITSOROZAT DETEKTOR

module moore_det_1 (clock, in_bit, out_bit); input clock, in_bit; output out_bit; reg [2:0] state_reg, next_state; `define start_state 3’b000 `define read_1_zero 3’b001 `define read_1_one 3’b010 `define read_2_zero 3’b011 `define read_2_one 3’b100

read_2_one

101

0

01

0

1

0

11

0

start_state

read_1_one

read_2_zero

read_1_zero

00 1

output value

input bit

48

MOORE FSM - BITSOROZAT DETEKTOR

always @ (posedge clock) state_reg = next_state; assign out_bit = ((state_reg == ‘read_2_zero) || (state_reg == `read_2_one)) ? 1 : 0; always @ (state_reg or in_bit) case (state_reg) `start_state: if (in_bit == 0) next_state = `read_1_zero; else if (in_bit == 1) next_state = `read_1_one; else next_state = `start_state; `read_1_zero: if (in_bit == 0) next_state = `read_2_zero else if (in_bit == 1) next_state = `read_1_one; else next_state = `start_state; `read_2_zero: if (in_bit == 0) next_state = `read_2_zero; else if (in_bit == 1) next_state = `read_1_one; else next_state = `start_state; `read_1_one: if (in_bit == 0) next_state = `read_1_zero; else if (in_bit == 1) next_state = `read_2_one; else next_state = `start_state; `read_2_one: if (in_bit == 0) next_state = `read_1_zero else if (in_bit == 1) next_state = `read_2_one; else next_state = `start_state; default: next_state = `start_state; endcase endmodule Megjegyzés: A kimenet csak az állapottól függ.

49

IMPLICIT VÉGES ÁLLAPOTÚ VEZÉRLŐK (FSM)

LEÍRÁSI STÍLUS: Elhagyjuk az állapotregiszter explicit deklarációját. Többszörös élvezérelt eseményvezérlés használunk ugyanabban a viselkedési leírásban. Ezen feltételek mellett a szintézis eszközök implicit vezérlőt valósítanak meg. • MINDEN ESEMÉNYVEZÉRLÉS MEGFELEL EGY ÁLLAPOTÁTMENETNEK. • A KÓD VÉGREHAJTÁSÁNAK FOLYAMATA MAGÁBAN HORDOZZA AZ

ÁLLAPOTOK SORENDISÉGÉT.

MEGJEGYZÉS: Az implicit FSM-ek a vezérlőket magasabb szinten írják le, mint az explicit FSM-ek, ezért kevesebb utasítást, rövidebb kódot eredményeznek.

50

PÉLDA IMPLICIT FSM SZINTÉZISRE

always @ (posedge clk) // Szinkronizáló esemény a kezdeti értékadások előtt begin reg_a = reg_b; // Végrehajtódik az első órajelciklusban reg_c = reg_d; // Végrehajtódik az első órajelciklusban @ (posedge clk) // Várakozás a második órajelciklusra begin reg_g = reg_f; // Végrehajtódik a második órajelciklusban reg_m = reg_r; // Végrehajtódik a második órajelciklusban end end

Az implicit FSM esetében az órajel élek definiálják a vezérlő állapotátmeneteinek határát.

51

ÓRAJEL SZINKRONIZÁCIÓ AZ IMPLICIT FSM SZINTÉZISEKOR

SZABÁLYOK: Az implicit FSM-ek minden állapotváltozását ugyanazon órajel ugyanazon éléhez kell szinkronizálni. (ez lehet akár a posedge akár a negedge.) NEM MEGENGEDHEŐ VEZÉRLÉSI STRUKTÚRA

always @ (posedge clk) // Szinkronizáló esemény a kezdeti értékadások előtt begin reg_a = reg_b; // Végrehajtódik az első órajelciklusban reg_c = reg_d; // Végrehajtódik az első órajelciklusban @ (negedge clk) // Illegális órajelütemezési struktúra begin reg_g = reg_f; reg_m = reg_r; end end // A SZINTÉZIS SIKERTELEN

52

AZ IMPLICIT ÉS EXPLICIT FSM ÖSSZEHSONLÍTÁSA

ÁLLAPOTOKSORRENDJE

EXPLICIT ÁLLAPOTREGISTER

ÁLLAPOTVEZÉRLÉS

ÁLLAPOTKÓDOLÁS

EXPLICIT FSM IMPLICIT FSM

IGEN NINCS

IGEN

SPECIFIKÁLT IMPLICIT

NINCS

A FORRÁSKÓD LEÍRÁSA SZABJA

MEG

EXPLICIT ÉRTÉKADÁS AZ ÁLLAPOT- REGISZTERRE

53

ÁLLAPOTKÓDOLÁSI LEHETŐSÉGEK

• A SZINTÉZIS ESZKÖZÖK ÁLTAL AUTOMATIKUSAN GENERÁLT ÁLLAPOTKÓDOLÁS

NEM MINDIG OPTIMÁLIS. • SOKSZOR SZÜKSÉGES AZ ÁLLAPOTKÓDOLÁS MANUÁLIS MÓDOSÍTÁSA • AZ NYELV MINDKÉT MEGOLDÁST TÁMOGATJA: FELHASZNÁLÓI ÁLTALI KÖZVETLEN

ÁLLAPOTKÓDOLÁS ELŐÍRÁSA VAGY AUTOMATIKUS ÁLLAPOTKÓDOLÁS.

54

1 AZ N-BŐL (ONE-HOT) ÁLLAPOTKÓDOLÁS

• Az 1 az N-ből állapotkódolás minden állapothoz egy regiszterbitet rendel a vezérlőben. • Az 1 az N-ből kódolás nem kanonikus a flip-flop-ok számát illetően. • Előnye: Az 1 az N-ből kódolás jelentősen csökkenti a következő állapotlogika és a

kimeneti logika áramköri és huzalozási komplexitását.

PÉLDA

`define state_0 3’b001 `define state_1 3’b010 `define state_2 3’b100

FIGYELEM: AZ ÁLLAPOT DEKÓDOLÁSÁHOZ HASZNÁLJUNK ’if’ UTASÍTÁST

(A ’case’ utasítás implicit módon a teljes állapotregisztert teszteli, tehát a dekódolás során

szükségtelenül komplex logikához vezet.)