Veriwell - Automate Finite

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 Telecomunicaţii din cadrul Universităţii POLITEHNICA Bucureşti (unele programe, parţial modificate, folosite în lucrările de laborator anterioare provin din aceeaşi sursă) URL: http://agni.arh.pub.ro/george.htm

1. Scopul lucrării Implementarea unor automate cu stări finite în Verilog folosind descrierea comportamentală a lor şi testarea funcţionării lor pentru diferite situaţii date de modificarea intrărilor.

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. Consideraţii teoretice Pentru început ne propunem să proiectăm un automat finit pentru comanda unui semafor. Semaforul este amplasat la intersecţia a două străzi (sunt 4 semafoare, câte unul pentru fiecare direcţie şi sens, dar este suficient să facem comanda pentru unul singur şi să conectăm diferit ieşirile lui: ieşirea de roşu pentru una din străzi se conectează la ieşirea de verde de pe cealaltă direcţie). Secvenţa normală a luminilor este roşu – galben – verde – galben – roşu, duratele de menţinere a lor fiind de 20 secunde pentru roşu şi verde şi de 4 secunde pentru galben. Există şi două intrări, tr_a şi tr_b, care informează automatul despre existenţa traficului pe cele două direcţii, permiţând comanda „inteligentă” a semaforului: - dacă nu există maşini în trafic, atunci semaforul funcţionează normal - dacă există maşini pe ambele străzi, avem tot funcţionare normală - dacă sunt maşini numai pe direcţia permisă la un moment dat (pentru care avem „verde”), atunci semaforul rămâne pe verde încă 20 secunde; dacă era pe „roşu”, atunci va trece pe „verde” - dacă sunt detectate maşini numai pe cealaltă direcţie (nepermisă în momentul respectiv, pentru care avem „roşu”), atunci semaforul trece pe „roşu” (permiţând trecerea pe cealaltă direcţie, care trece în „verde”)

1

B

test1

galben

C

A

test1

test2

verde

rosu

D

test2

galben

Fig. 3.1 Funcţionarea automatului care comandă semaforul Dacă introducem următoarele condiţii de test: test1 = tr_a tr_b (nu există trafic pe strada a, dar există pe b; se rămâne pe „roşu”), respectiv test2 = tr_a tr_b (există trafic pe strada a şi nu există pe b; se rămâne pe „verde”), atunci diagrama stărilor din figura 3.1 descrie funcţionarea automatului care comandă semaforul. Se poate uşor observa că avem de-a face cu un automat Moore imediat, deoarece ieşirile depind numai de starea în care se află automatul, nu şi de intrările curente ale automatului. Problema care mai rămâne este dată de faptul că duratele stărilor diferă: stările A şi C trebuie să se menţină pentru cel puţin 20 secunde, iar duratele stărilor B şi D au numai 4 secunde. Fie construim un sistem cu două ceasuri diferite, dar sincronizate între ele, fie multiplicăm numărul de stări, astfel încât toate stările să dureze 4 secunde, iar aprinderea becurilor de „roşu” şi „verde” să se facă pe durata a 5 stări. Dacă adoptăm ultima variantă, atunci organigrama automatului este cea din figura 3.2. Codurile alese pentru cele 12 stări 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

A1

0011

0010

A2

rosu

rosu

A3

0100

A4

rosu

0101

A5

rosu

rosu

1010 1 1111

C5

verde

0000

D

galben

0

1110

test2

C4

1101

C3

verde

verde

test1

0

1100

C2

verde

B 1011

C1

1

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

galben

verde

endcase

// 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

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

Modulul de test poate avea următoarea 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

end

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;

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

$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});

endmodule

Al doilea automat de care ne ocupăm este un automat de recunoaştere a unei secvenţe regulate de forma „aaa...aacbb.....b”. Automatul primeşte la intrare simboluri care pot avea valoarea a, b, c sau e; „e” este simbolul neutru, folosit pentru delimitarea secvenţei urmărite (este prezent la începutul şi sfârşitul secvenţei). Secvenţa corectă conţine un număr arbitrar de simboluri „a”, un singur simbol „c”, şi un număr arbitrar de simboluri „b”.

3

e/found_good e/found_bad e/waiting_start

q0 a,b,c/ waiting_end

q1

a/working

q2

c/working

q3

b/working

q4

b,c/found_bad e/waiting_start

b/working

a/working

b,e/found_bad a,c/found_bad

a,c/found_bad

Fig. 3.3 Diagrama stărilor pentru automatul care recunoaşte secvenţa de caractere Automatul propus trebuie să recunoască 4 caractere la intrare, caractere care pot fi codificate binar pe 2 biţi: alocăm codul 00 pentru caracterul „a”, codul 01 pentru „b”, codul 10 pentru „c” şi codul 11 pentru „e”. La ieşire avem nevoie de următoarele 5 mesaje, care se pot codifica pe 3 biţi: 000 pentru „waiting_end” (aşteaptă sfârşitul secvenţei greşite), 001 pentru „waiting_start” (aşteaptă începutul unei secvenţe), 111 pentru „working” (lucrează la citirea unei secvenţe), 010 pentru „found_bad” (găsit secvenţă greşită) şi 100 pentru „found_good” (găsit secvenţă corectă). Diagrama stărilor este prezentată în figura 3.3. Observăm că avem un automat Mealy, cele 5 ieşiri fiind dependente de intrare şi de stare. Modelul Verilog care descrie comportamental automatul este dat mai jos. Pentru claritate, intrările, ieşirile şi stările 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

// State codes parameter

// Output codes parameter

a = 2'b00, b = 2'b01, c = 2'b10, e = 2'b11; q0 q1 q2 q3 q4

= = = = =

3'b000, 3'b001, 3'b010, 3'b011, 3'b100;

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

endcase

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

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

Fişierul 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 găseşte în directorul care conţine celelalte programe prezentate. Al treilea automat prezentat aici este o cheie electronică cu 11 butoane: init, s0, s1, ..., s9. Secvenţa corectă care permite accesul în spaţiul supravegheat este „init s1 s7 s2 s4”. Activarea lui „init” declanşează un semnal care rămâne activ timp de 5 secunde. Următoarele 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 intrările sunt sincronizate cu semnalul de ceas. Prezentăm mai jos numai o parte din modelul Verilog al acestui automat, care se găseşte în fişierul 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 execuţie VeriWell 2.0, se vizualizează fişierele semafor.v şi test_semafor.v şi se deschide proiectul care conţine cele două fişiere. Rulaţi proiectul, vizualizaţi formele de undă şi explicaţi funcţionarea circuitului, urmărind modificarea ieşirilor în funcţie de intrări. Modificaţi descrierea automatului prin introducerea semnalizărilor pentru pietonii care doresc să traverseze intersecţia. Propunem introducerea unui număr de două ieşiri, „roşu” şi „verde”, dar, înainte de apariţia lui „roşu” pentru pietoni, care se produce atunci când se semnalizează „galben” în intersecţie, 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ă fişierele recunoastere.v şi test_recunoastere.v şi se deschide proiectul care conţine cele două fişiere. Rulaţi proiectul şi observaţi rezultatele rulării pentru secvenţa de testare propusă în fereastra de consolă. Fişierul 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 biţi. Deplasarea spre dreapta se face cu un simbol, adică cu doi biţi. Simbolul cel mai din dreapta este încărcat pe poziţia din stânga. Intrarea automatului într-un anumit moment este simbolul din dreapta. Verificaţi funcţionarea automatului şi cu alte secvenţe propuse în fişier (cele introduse ca şi comentarii). 4.3. Se vizualizează fişierele cheie.v şi test_cheie.v şi se studiază modul în care au fost realizate. Se deschide proiectul care conţine cele două fişiere. Rulaţi proiectul şi observaţi rezultatele rulării pentru secvenţa de testare propusă în fereastra de consolă. Observaţi că nu se pot vizualiza toate formele de undă, pentru că versiunea utilizată a programului este limitată la un număr de 10 semnale. Modificaţi lista de semnale, astfel încât să reuşiţi să vizualizaţi numai semnalele care ne interesează. Simulaţi funcţionarea circuitului şi pentru alte combinaţii de intrări. 4.4. Concepeţi proiectul unui automat finit destinat comenzii unui lift pentru o clădire de 6 etaje. Verificaţi funcţionarea corectă a proiectului prin simulare.

6