Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  

CATEGORII DOCUMENTE





AccessAdobe photoshopAlgoritmiAutocadBaze de dateCC sharp
CalculatoareCorel drawDot netExcelFox proFrontpageHardware
HtmlInternetJavaLinuxMatlabMs dosPascal
PhpPower pointRetele calculatoareSqlTutorialsWebdesignWindows
WordXml


AUTOMATE FINITE IMPLEMENTATE IN VERILOG

algoritmi

+ Font mai mare | - Font mai mic







DOCUMENTE SIMILARE

Trimite pe Messenger
Sistem informational – Sistem informatic
Arbori de decizie - Inteligenta artificiala
F# programming - Introducing Functional Programming
Algoritmi speciali - Sortarea unui vector
Algoritmi semnatura digitala
Evaluarea corectitudinii algoritmilor
Tipuri de limbaje de programare
Scheme logice si pseudocod - Reprezentarea algoritmilor prin scheme logice
Structuri de date
Probleme cu algoritmi si cheme logice

AUTOMATE FINITE

 implementate In verilog



Nota: Toate programele sursa folosite in aceasta lucrare au fost preluate de pe pagina Web a domnului prof. dr. ing. Gheorghe Stefan, de la Facultatea de Electronica si Telecomunicatii din cadrul Universitatii POLITEHNICA Bucuresti (unele programe, partial modificate, folosite in lucrarile de laborator anterioare provin din aceeasi sursa) URL: http://agni.arh.pub.ro/george.htm

1. Scopul lucrarii

 

            Implementarea unor automate cu stari finite in Verilog folosind descrierea comportamentala a lor si testarea functionarii lor pentru diferite situatii date de modificarea intrarilor.

2. Aparate necesare 

 

- calculator compatibil Pentium

- sistem de operare Windows 95 sau superior

- programul VeriWell 2.0, produs de Wellspring Solutions, versiunea freeware, disponibila pe Internet

3. Consideratii teoretice

 

            Pentru inceput ne propunem sa proiectam un automat finit pentru comanda unui semafor. Semaforul este amplasat la intersectia a doua strazi (sunt 4 semafoare, cate unul pentru fiecare directie si sens, dar este suficient sa facem comanda pentru unul singur si sa conectam diferit iesirile lui: iesirea de rosu pentru una din strazi se conecteaza la iesirea de verde de pe cealalta directie).

            Secventa normala a luminilor este rosu – galben – verde – galben – rosu, duratele de mentinere a lor fiind de 20 secunde pentru rosu si verde si de 4 secunde pentru galben. Exista si doua intrari, tr_a si tr_b, care informeaza automatul despre existenta traficului pe cele doua directii, permitand comanda „inteligenta” a semaforului:

                        - daca nu exista masini in trafic, atunci semaforul functioneaza normal

                        - daca exista masini pe ambele strazi, avem tot functionare normala

                        - daca sunt masini numai pe directia permisa la un moment dat (pentru care avem „verde”), atunci semaforul ramane pe verde inca 20 secunde; daca era pe „rosu”, atunci va trece pe „verde”

                        - daca sunt detectate masini numai pe cealalta directie (nepermisa in momentul respectiv, pentru care avem „rosu”), atunci semaforul trece pe „rosu” (permitand trecerea pe cealalta directie, care trece in „verde”)

Fig. 3.1   Functionarea automatului care comanda semaforul

Daca introducem urmatoarele conditii de test: test1 = tr_a tr_b (nu exista trafic pe strada a, dar exista pe b; se ramane pe „rosu”), respectiv test2 = tr_a tr_b (exista trafic pe strada a si nu exista pe b; se ramane pe „verde”), atunci diagrama starilor din figura 3.1 descrie functionarea automatului care comanda semaforul.

Se poate usor observa ca avem de-a face cu un automat Moore imediat, deoarece iesirile depind numai de starea in care se afla automatul, nu si de intrarile curente ale automatului. Problema care mai ramane este data de faptul ca duratele starilor difera: starile A si C trebuie sa se mentina pentru cel putin 20 secunde, iar duratele starilor B si D au numai 4 secunde. Fie construim un sistem cu doua ceasuri diferite, dar sincronizate intre ele, fie multiplicam numarul de stari, astfel incat toate starile sa dureze 4 secunde, iar aprinderea becurilor de „rosu” si „verde” sa se faca pe durata a 5 stari. Daca adoptam ultima varianta, atunci organigrama automatului este cea din figura 3.2. Codurile alese pentru cele 12 stari ale automatului au fost trecute in figura. Descrierea comportamentala a circuitului este data in 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

 

 

Fig. 3.2   Organigrama automatului care comanda semaforul

always @(state_reg or tr_a or tr_b)

            case (state_reg)

4'b0000: = ;

// the cross must be evacuated

                        4'b0001: = ;

// free for cars from the street b

                        4'b0010: = ;

                        4'b0011: = ;

                        4'b0100: = ;

                        4'b0101: if (~tr_a && tr_b) // no trafic on a and trafic on b: light must not change

                                                = ;



// the light remains red

                                    else = ;

// trafic will change

                        4'b1010: = ;

                        4'b1011: = ;

// free for cars from the street a

                        4'b1100: = ;

                        4'b1101: = ;

                        4'b1110: = ;

                        4'b1111: if (tr_a && ~tr_b) // no trafic on b and trafic on a: light must not change

                                                = ;

// the light remains green

                                    else = ;

// trafic will change

            endcase

   

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

                                                else     state_reg = next_state;

   

endmodule

              Modulul de test poate avea urmatoarea structura:

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;

                                    = 2'b00;

                                    #4  reset = 0;

                                    #30 = 2'b01;

                                    #50 = 2'b10;

                                    #90 = 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, , dut.state_reg, );

                        end

endmodule

            Al doilea automat de care ne ocupam este un automat de recunoastere a unei secvente regulate de forma „aaaaacbb..b”. Automatul primeste la intrare simboluri care pot avea valoarea a, b, c sau e; „e” este simbolul neutru, folosit pentru delimitarea secventei urmarite (este prezent la inceputul si sfarsitul secventei). Secventa corecta contine un numar arbitrar de simboluri „a”, un singur simbol „c”, si un numar arbitrar de simboluri „b”.

Fig. 3.3   Diagrama starilor pentru automatul care recunoaste secventa de caractere

            Automatul propus trebuie sa recunoasca 4 caractere la intrare, caractere care pot fi codificate binar pe 2 biti: alocam codul 00 pentru caracterul „a”, codul 01 pentru „b”, codul 10 pentru „c” si codul 11 pentru „e”. La iesire avem nevoie de urmatoarele 5 mesaje, care se pot codifica pe 3 biti: 000 pentru „waiting_end” (asteapta sfarsitul secventei gresite), 001 pentru „waiting_start” (asteapta inceputul unei secvente), 111 pentru „working” (lucreaza la citirea unei secvente), 010 pentru „found_bad” (gasit secventa gresita) si 100 pentru „found_good” (gasit secventa corecta).

            Diagrama starilor este prezentata in figura 3.3. Observam ca avem un automat Mealy, cele 5 iesiri fiind dependente de intrare si de stare. Modelul Verilog care descrie comportamental automatul este dat mai jos. Pentru claritate, intrarile, iesirile si starile 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)

                                    q0: if (in == e) = ;

                                                            else       = ;

                                    q1: case (in)

                                                            a: = ; // arrived the first a

                                                            b: = ;

                                                            c: = ;

                                                e: = ;

                                          endcase

                                    q2: case (in)

                                                            a: = ; // follows many a's

                                                            b: = ;

                                                            c: = ; // arrived the c

                                                            e: = ;

                                          endcase

                                    q3: case (in)

                                                            a: = ;

                                                            b: = ; // arrived the first b

                                                            c: = ;

                                                            e: = ;

                                          endcase

                                    q4: case (in)

                                                            a: = ;

                                                            b: = ; // follows many b's

                                                            c: = ;

                                                            e: = ; // hitt

                                          endcase

                        endcase

 

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

                                                else state_reg = next_state;

endmodule

Fisierul de testare pentru acest circuit, test_recunoastere.v, introduce simbolurile de intrare cu ajutorul unui registru de deplasare. Programul sursa nu este prezentat aici, el se gaseste in directorul care contine celelalte programe prezentate.

            Al treilea automat prezentat aici este o cheie electronica cu 11 butoane: init, s0, s1, , s9. Secventa corecta care permite accesul in spatiul supravegheat este „init s1 s7 s2 s4”. Activarea lui „init” declanseaza un semnal care ramane activ timp de 5 secunde. Urmatoarele 4 semnale trebuie sa fie aplicate numai in acest interval de timp. Daca codul este corect introdus, se genereaza semnalul „go”. In caz contrar, se activeaza semnalul „alarm” si automatul trebuie restartat. Toate intrarile sunt sincronizate cu semnalul de ceas. Prezentam mai jos numai o parte din modelul Verilog al acestui automat, care se gaseste in fisierul 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 = ;

 

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

 

            always @(state_reg or signals)

                        case (state_reg)

                             q0 :             if (init) = ;

                                                            else    = ;

                             q1 :             if (signals == 11'b10000000000) = ;

                                                else if (signals == 11'b10100000000) = ;

                                    else = ;

                             .

                             q9 : if (signals == 11'b10000000000) = ;

                                    else if (signals == 11'b0) = ;

                                    else = ;

                            q10: = ;

                            q11: = ;

                        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;

                                                                        = out;

                                                end

endmodule

4. Modul de lucru

4.1. Se lanseaza in executie VeriWell 2.0, se vizualizeaza fisierele semafor.v si test_semafor.v si se deschide proiectul care contine cele doua fisiere. Rulati proiectul, vizualizati formele de unda si explicati functionarea circuitului, urmarind modificarea iesirilor in functie de intrari. Modificati descrierea automatului prin introducerea semnalizarilor pentru pietonii care doresc sa traverseze intersectia. Propunem introducerea unui numar de doua iesiri, „rosu” si „verde”, dar, inainte de aparitia lui „rosu” pentru pietoni, care se produce atunci cand se semnalizeaza „galben” in intersectie, lumina „verde” trebuie sa se aprinda si sa se stinga intermitent cu o frecventa de 1 Hz, timp de 8 secunde.

4.2. Se vizualizeaza fisierele recunoastere.v si test_recunoastere.v si se deschide proiectul care contine cele doua fisiere. Rulati proiectul si observati rezultatele rularii pentru secventa de testare propusa in fereastra de consola. Fisierul 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 biti. Deplasarea spre dreapta se face cu un simbol, adica cu doi biti. Simbolul cel mai din dreapta este incarcat pe pozitia din stanga. Intrarea automatului intr-un anumit moment este simbolul din dreapta. Verificati functionarea automatului si cu alte secvente propuse in fisier (cele introduse ca si comentarii).

4.3. Se vizualizeaza fisierele cheie.v si test_cheie.v si se studiaza modul in care au fost realizate. Se deschide proiectul care contine cele doua fisiere. Rulati proiectul si observati rezultatele rularii pentru secventa de testare propusa in fereastra de consola. Observati ca nu se pot vizualiza toate formele de unda, pentru ca versiunea utilizata a programului este limitata la un numar de 10 semnale. Modificati lista de semnale, astfel incat sa reusiti sa vizualizati numai semnalele care ne intereseaza. Simulati functionarea circuitului si pentru alte combinatii de intrari.

4.4. Concepeti proiectul unui automat finit destinat comenzii unui lift pentru o cladire de 6 etaje. Verificati functionarea corecta a proiectului prin simulare.








Politica de confidentialitate

DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 1296
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2019 . All rights reserved

Distribuie URL

Adauga cod HTML in site