AUTOMATE FINITE

IMPLEMENTATE N VERILOG

Not: Toate programele surs folosite n aceast

lucrare au fost preluate de pe pagina Web a
domnului prof. dr. ing. Gheorghe tefan, de la
Facultatea de Electronic i Telecomunicaii din
cadrul Universitii POLITEHNICA Bucureti
(unele programe, parial modificate, folosite n
lucrrile de laborator anterioare provin din aceeai
surs) URL: http://agni.arh.pub.ro/george.htm

1. Scopul lucrrii
Implementarea unor automate cu stri finite n Verilog folosind descrierea
comportamental a lor i testarea funcionrii lor pentru diferite situaii date de
modificarea intrrilor.

2. Aparate necesare
- calculator compatibil Pentium
- sistem de operare Windows 95 sau superior
- programul VeriWell 2.0, produs de Wellspring Solutions, versiunea
freeware, disponibil pe Internet

3. Consideraii teoretice
Pentru nceput ne propunem s proiectm un automat finit pentru comanda unui
semafor. Semaforul este amplasat la intersecia a dou strzi (sunt 4 semafoare, cte
unul pentru fiecare direcie i sens, dar este suficient s facem comanda pentru unul
singur i s conectm diferit ieirile lui: ieirea de rou pentru una din strzi se
conecteaz la ieirea de verde de pe cealalt direcie).
Secvena normal a luminilor este rou galben verde galben rou,
duratele de meninere a lor fiind de 20 secunde pentru rou i verde i de 4 secunde
pentru galben. Exist i dou intrri, tr_a i tr_b, care informeaz automatul despre
existena traficului pe cele dou direcii, permind comanda inteligent a
semaforului:
- dac nu exist maini n trafic, atunci semaforul funcioneaz normal
- dac exist maini pe ambele strzi, avem tot funcionare normal
- dac sunt maini numai pe direcia permis la un moment dat (pentru
care avem verde), atunci semaforul rmne pe verde nc 20 secunde; dac
era pe rou, atunci va trece pe verde
- dac sunt detectate maini numai pe cealalt direcie (nepermis n
momentul respectiv, pentru care avem rou), atunci semaforul trece pe
rou (permind trecerea pe cealalt direcie, care trece n verde)

1
 B
test1 galben

test1 A C test2
rosu verde

D test2
galben

Fig. 3.1 Funcionarea automatului care comand semaforul

Dac introducem urmtoarele condiii de test: test1 = tr_a tr_b (nu exist trafic
pe strada a, dar exist pe b; se rmne pe rou), respectiv test2 = tr_a tr_b (exist
trafic pe strada a i nu exist pe b; se rmne pe verde), atunci diagrama strilor din
figura 3.1 descrie funcionarea automatului care comand semaforul.
Se poate uor observa c avem de-a face cu un automat Moore imediat,
deoarece ieirile depind numai de starea n care se afl automatul, nu i de intrrile
curente ale automatului. Problema care mai rmne este dat de faptul c duratele
strilor difer: strile A i C trebuie s se menin pentru cel puin 20 secunde, iar
duratele strilor B i D au numai 4 secunde. Fie construim un sistem cu dou ceasuri
diferite, dar sincronizate ntre ele, fie multiplicm numrul de stri, astfel nct toate
strile s dureze 4 secunde, iar aprinderea becurilor de rou i verde s se fac pe
durata a 5 stri. Dac adoptm ultima variant, atunci organigrama automatului este
cea din figura 3.2. Codurile alese pentru cele 12 stri ale automatului au fost trecute n
figur. Descrierea comportamental a circuitului este dat n modulul de mai jos:
module trafic_light_aut(green, yellow, red, tr_a, tr_b, reset, clock);

input tr_a, // trafic on the direction a

tr_b, // trafic on the direction b
reset, clock;

output green, yellow, red; // each output activates one collor

reg green, yellow, red; // variable used to compute the outputs

reg[3:0] state_reg, // the state register; will be synthetized as an actual register

next_state; // the variable used to compute the next state

0001 0010 0011 0100 0101

A1 rosu A2 rosu A3 rosu A4 rosu A5 rosu
1010
1 0 B
test1 galben

1111 1110 1101 1100 1011

C5 verde C4 verde C3 verde C2 verde C1 verde
0000
D 0 1
galben test2
Fig. 3.2 Organigrama automatului care comand semaforul
always @(state_reg or tr_a or tr_b)
case (state_reg)
4'b0000: {next_state, green, yellow, red} = {4'b0001, 1'b0, 1'b1, 1'b0};

2
 // the cross must be evacuated
4'b0001: {next_state, green, yellow, red} = {4'b0010, 1'b0, 1'b0, 1'b1};
// free for cars from the street b
4'b0010: {next_state, green, yellow, red} = {4'b0011, 1'b0, 1'b0, 1'b1};
4'b0011: {next_state, green, yellow, red} = {4'b0100, 1'b0, 1'b0, 1'b1};
4'b0100: {next_state, green, yellow, red} = {4'b0101, 1'b0, 1'b0, 1'b1};
4'b0101: if (~tr_a && tr_b) // no trafic on a and trafic on b: light must not change
{next_state, green, yellow, red} = {4'b0001, 1'b0, 1'b0, 1'b1};
// the light remains red
else {next_state, green, yellow, red} = {4'b1010, 1'b0, 1'b0, 1'b1};
// trafic will change
4'b1010: {next_state, green, yellow, red} = {4'b1011, 1'b0, 1'b1, 1'b0};
4'b1011: {next_state, green, yellow, red} = {4'b1100, 1'b1, 1'b0, 1'b0};
// free for cars from the street a
4'b1100: {next_state, green, yellow, red} = {4'b1101, 1'b1, 1'b0, 1'b0};
4'b1101: {next_state, green, yellow, red} = {4'b1110, 1'b1, 1'b0, 1'b0};
4'b1110: {next_state, green, yellow, red} = {4'b1111, 1'b1, 1'b0, 1'b0};
4'b1111: if (tr_a && ~tr_b) // no trafic on b and trafic on a: light must not change
{next_state, green, yellow, red} = {4'b1011, 1'b1, 1'b0, 1'b0};
// the light remains green
else {next_state, green, yellow, red} = {4'b0000, 1'b1, 1'b0, 1'b0};
// trafic will change
endcase

always @(posedge clock) if (reset) state_reg = 0;

else state_reg = next_state;

endmodule

Modulul de test poate avea urmtoarea structur:

module trafic_aut_test;

reg tr_a, tr_b, reset, clock;

wire green, yellow, red;

initial begin clock = 0;

forever #2 clock = ~clock;
end

initial begin reset = 1;

{tr_a, tr_b} = 2'b00;
#4 reset = 0;
#30 {tr_a, tr_b} = 2'b01;
#50 {tr_a, tr_b} = 2'b10;
#90 {tr_a, tr_b} = 2'b11;
#90 $stop;
end

trafic_light_aut dut(green, yellow, red, tr_a, tr_b, reset, clock);

initial begin $vw_dumpvars;

$monitor("time=%0d clock=%b trafic=%b state=%b color=%b",
$time, clock, {tr_a, tr_b}, dut.state_reg, {green, yellow, red});
end

endmodule

Al doilea automat de care ne ocupm este un automat de recunoatere a unei

secvene regulate de forma aaa...aacbb.....b. Automatul primete la intrare simboluri
care pot avea valoarea a, b, c sau e; e este simbolul neutru, folosit pentru delimitarea
secvenei urmrite (este prezent la nceputul i sfritul secvenei). Secvena corect
conine un numr arbitrar de simboluri a, un singur simbol c, i un numr arbitrar
de simboluri b.

3
 e/found_good

e/found_bad
e/waiting_start
a/working c/working b/working
q0 q1 q2 q3 q4
a,b,c/ b,c/found_bad
waiting_end
e/waiting_start a/working b/working

b,e/found_bad

a,c/found_bad a,c/found_bad

Fig. 3.3 Diagrama strilor pentru automatul care recunoate secvena de caractere

Automatul propus trebuie s recunoasc 4 caractere la intrare, caractere care

pot fi codificate binar pe 2 bii: alocm codul 00 pentru caracterul a, codul 01 pentru
b, codul 10 pentru c i codul 11 pentru e. La ieire avem nevoie de urmtoarele 5
mesaje, care se pot codifica pe 3 bii: 000 pentru waiting_end (ateapt sfritul
secvenei greite), 001 pentru waiting_start (ateapt nceputul unei secvene), 111
pentru working (lucreaz la citirea unei secvene), 010 pentru found_bad (gsit
secven greit) i 100 pentru found_good (gsit secven corect).
Diagrama strilor este prezentat n figura 3.3. Observm c avem un automat
Mealy, cele 5 ieiri fiind dependente de intrare i de stare. Modelul Verilog care descrie
comportamental automatul este dat mai jos. Pentru claritate, intrrile, ieirile i strile
sunt definite ca parametri:
module rec_aut(out, in, reset, clock);

input reset, clock;

input[1:0] in;

output[2:0] out;

reg[2:0] state_reg, next_state, out;

// Input codes
parameter a = 2'b00,
b = 2'b01,
c = 2'b10,
e = 2'b11;

// State codes
parameter q0 = 3'b000,
q1 = 3'b001,
q2 = 3'b010,
q3 = 3'b011,
q4 = 3'b100;

// Output codes
parameter waiting_end = 3'b000,
waiting_start = 3'b001,
working = 3'b111,
found_bad = 3'b010,
found_good = 3'b100;

always @(state_reg or in)

case (state_reg)

4
 q0: if (in == e) {next_state, out} = {q1, waiting_start};
else {next_state, out} = {q0, waiting_end};
q1: case (in)
a: {next_state, out} = {q2, working}; // arrived the first a
b: {next_state, out} = {q0, found_bad};
c: {next_state, out} = {q0, found_bad};
e: {next_state, out} = {q1, waiting_start};
endcase
q2: case (in)
a: {next_state, out} = {q2, working}; // follows many a's
b: {next_state, out} = {q0, found_bad};
c: {next_state, out} = {q3, working}; // arrived the c
e: {next_state, out} = {q1, found_bad};
endcase
q3: case (in)
a: {next_state, out} = {q0, found_bad};
b: {next_state, out} = {q4, working}; // arrived the first b
c: {next_state, out} = {q0, found_bad};
e: {next_state, out} = {q1, found_bad};
endcase
q4: case (in)
a: {next_state, out} = {q0, found_bad};
b: {next_state, out} = {q4, working}; // follows many b's
c: {next_state, out} = {q0, found_bad};
e: {next_state, out} = {q1, found_good}; // hitt
endcase
endcase

always @(posedge clock) if (reset) state_reg = 0;

else state_reg = next_state;

endmodule
Fiierul de testare pentru acest circuit, test_recunoastere.v, introduce simbolurile de
intrare cu ajutorul unui registru de deplasare. Programul surs nu este prezentat aici, el
se gsete n directorul care conine celelalte programe prezentate.
Al treilea automat prezentat aici este o cheie electronic cu 11 butoane: init, s0,
s1, ..., s9. Secvena corect care permite accesul n spaiul supravegheat este init s1 s7
s2 s4. Activarea lui init declaneaz un semnal care rmne activ timp de 5 secunde.
Urmtoarele 4 semnale trebuie s fie aplicate numai n acest interval de timp. Dac
codul este corect introdus, se genereaz semnalul go. n caz contrar, se activeaz
semnalul alarm i automatul trebuie restartat. Toate intrrile sunt sincronizate cu
semnalul de ceas. Prezentm mai jos numai o parte din modelul Verilog al acestui
automat, care se gsete n fiierul cheie.v:
module el_key(go, alarm, clock, restart, init, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9);

input clock, restart, init, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
output go, alarm;

reg[3:0] state_reg, next_state;

reg go, alarm;
wire[10:0] signals;

parameter q0 = 4'b0000, // states coding

q1 = 4'b0001,
.....................
q11 = 4'b1011;

parameter ok = 1'b1, // outputs coding

n_ok = 1'b1,
n = 1'b0;

assign signals = {init, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9};

// the combinational circuit that computes 'next_state' and the outputs 'out'

always @(state_reg or signals)

case (state_reg)

5
 q0 : if (init) {next_state, out} = {q1, n, n};
else {next_state, out} = {q0, n, n};
q1 : if (signals == 11'b10000000000) {next_state, out} = {q1, n, n};
else if (signals == 11'b10100000000) {next_state, out} = {q5, n, n};
else {next_state, out} = {q11, n, n};
..........................................................................................................
q9 : if (signals == 11'b10000000000) {next_state, out} = {q9, n, n};
else if (signals == 11'b0){next_state, out} = {q10, n, n};
else {next_state, out} = {q11, n, n};
q10: {next_state, out} = {q0, ok, n};
q11: {next_state, out} = {q11, n, n_ok};
endcase

// results a Moore automaton, because 'out' depends only by the state; a delayed variant:

always @(posedge clock) begin if (restart) state_reg = q0;

else state_reg = next_state;
{go, alarm} = out;
end
endmodule

4. Modul de lucru
4.1. Se lanseaz n execuie VeriWell 2.0, se vizualizeaz fiierele semafor.v i
test_semafor.v i se deschide proiectul care conine cele dou fiiere. Rulai
proiectul, vizualizai formele de und i explicai funcionarea circuitului, urmrind
modificarea ieirilor n funcie de intrri. Modificai descrierea automatului prin
introducerea semnalizrilor pentru pietonii care doresc s traverseze intersecia.
Propunem introducerea unui numr de dou ieiri, rou i verde, dar, nainte de
apariia lui rou pentru pietoni, care se produce atunci cnd se semnalizeaz galben
n intersecie, lumina verde trebuie s se aprind i s se sting intermitent cu o
frecven de 1 Hz, timp de 8 secunde.

4.2. Se vizualizeaz fiierele recunoastere.v i test_recunoastere.v i se

deschide proiectul care conine cele dou fiiere. Rulai proiectul i observai
rezultatele rulrii pentru secvena de testare propus n fereastra de consol. Fiierul de
testare pentru acest circuit introduce simbolurile de intrare cu ajutorul unui registru de
recirculare serie. Prin concatenarea celor 16 parametri se obtine un numar binar pe 32
bii. Deplasarea spre dreapta se face cu un simbol, adic cu doi bii. Simbolul cel mai
din dreapta este ncrcat pe poziia din stnga. Intrarea automatului ntr-un anumit
moment este simbolul din dreapta. Verificai funcionarea automatului i cu alte
secvene propuse n fiier (cele introduse ca i comentarii).

4.3. Se vizualizeaz fiierele cheie.v i test_cheie.v i se studiaz modul n

care au fost realizate. Se deschide proiectul care conine cele dou fiiere. Rulai
proiectul i observai rezultatele rulrii pentru secvena de testare propus n fereastra
de consol. Observai c nu se pot vizualiza toate formele de und, pentru c versiunea
utilizat a programului este limitat la un numr de 10 semnale. Modificai lista de
semnale, astfel nct s reuii s vizualizai numai semnalele care ne intereseaz.
Simulai funcionarea circuitului i pentru alte combinaii de intrri.

4.4. Concepei proiectul unui automat finit destinat comenzii unui lift pentru o
cldire de 6 etaje. Verificai funcionarea corect a proiectului prin simulare.