Differences
This shows you the differences between two versions of the page.
|
ac-is:lab:lab04 [2021/09/20 18:36] 127.0.0.1 external edit |
ac-is:lab:lab04 [2023/11/03 14:43] (current) teodor.dicu |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | = Laboratorul 4 - Limbajul Verilog: Circuite secvențiale = | + | ====== Laboratorul 4 - Limbajul Verilog: Circuite secvențiale - Partea I ====== |
| În laboratoarele anterioare au fost prezentate construcțiile Verilog pentru descrierea comportamentală a circuitelor combinaționale, ilustrate în exemplul următor. Laboratorul curent va prezenta elementele folosite pentru decrierea comportamentală a circuitelor secvențiale: | În laboratoarele anterioare au fost prezentate construcțiile Verilog pentru descrierea comportamentală a circuitelor combinaționale, ilustrate în exemplul următor. Laboratorul curent va prezenta elementele folosite pentru decrierea comportamentală a circuitelor secvențiale: | ||
| Line 7: | Line 7: | ||
| - | <code verilog Exemplu combinare instanțieri, atribuiri continue, blocuri comportamentale> | + | ===== Blocul always@ edge-triggered ===== |
| - | module simple_alu( | + | |
| - | output reg[7:0] out, | + | |
| - | input[3:0] a, b, | + | |
| - | input op); // operație: 0 - adunare, 1 - înmnulțire | + | |
| - | wire[4:0] sum; // ieșirea sumatorului | ||
| - | wire[7:0] sum_ext; // ieșirea sumatorului extinsă la dimensiunea ieșirii UAL-ului | ||
| - | wire[7:0] prod; // ieșirea multiplicatorului | + | În laboratoarele anterioare blocul ''always'' a fost prezentat drept o porțiune de cod ce modelează un anumit comportament, și care se execută ciclic la schimbarea valorii unor semnale. |
| - | // sumator 4 biți, ieșire 5 biți | + | În afară de circuitele care depind doar schimbarea nivelului semnalului, există și circuite al căror comportament depinde de tranzițiile semnalului (activ pe //front crescător// sau //front descrescător//). Starea bistabililor, de exemplu, se modifică pe frontul crescător sau descrescător al unui semnal de ceas. În cazul acesta, blocul ''always@'' trebuie să se execute la detecția unui astfel de front (eng. //edge-triggered//). Pentru a modela un astfel de comportament Verilog oferă cuvântul cheie **posedge** ce poate fi alăturat numelui semnalului unui semnal din lista de senzitivități pentru a indica activarea blocului ''always'' la un front al semnalului. De exemplu blocul "always @(posedge clk)" se activează pe frontul crescător al semnalului //clk//. |
| - | adder4 add(sum[3:0], sum[4], a, b, 1'b0); | + | |
| - | // multiplicator 4 biți, ieșire 8 biți | ||
| - | multiplier mul(prod, a, b); | ||
| - | // extinde ieșirea sumatorului, completând cu 0 | + | ==== Sensitivity list ==== |
| - | assign sum_ext = {3'b0, sum}; | + | |
| - | // selectează ieșirea UAL-ului în funcție de operație | ||
| - | always @(*) begin | ||
| - | case(op) | ||
| - | 0: out = sum_ext; | ||
| - | 1: out = prod; | ||
| - | default: out = 8'bx; | ||
| - | endcase | ||
| - | end | ||
| - | endmodule | + | Cuvintele cheie **posedge** (pentru front crescător) și **negedge** (pentru front descrescător) indică activarea blocului //always@ edge-triggered// la schimbarea frontului semnalului. |
| - | </code> | + | |
| - | În exemplul de mai sus au fost folosite atât instanțieri de module, ce țin de o descriere structurală cât și atribuiri continue și cod procedural, care realizează o descriere comportamentală. Instanțierile de module sau primitive se fac în afara blocurilor //always// și //initial//. Atribuirile cu //assign// sunt atriburi continue, și nu trebuie să fie puse în interiorul blocurilor //always// (cod executat ciclic), ci în afara acestora. | + | == Exemplu sensitivity list == |
| - | == Blocul always@ edge-triggered == | + | <code systemverilog> |
| + | always @(posedge sig) // frontul crescător al semnalului 'sig' | ||
| + | always @(negedge sig) // frontul descrescător al semnalului 'sig' | ||
| + | always @(posedge sig1, posedge sig2) // frontul crescator al | ||
| + | // semnalului 'sig1' sau frontul crescător al semnalului 'sig2' | ||
| + | always @(posedge sig1, negedge sig2) // frontul crescător al | ||
| + | // semnalului 'sig1' sau frontul descrescător al semnalului 'sig2' | ||
| + | </code> | ||
| - | În [[.:lab02 |laboratorul 2]], blocul //always@// a fost prezentat drept o porțiune de cod ce modelează un anumit comportament, și care se execută ciclic la schimbarea valorii unor semnale. | ||
| - | În afară de circuitele care depind doar schimbarea nivelului semnalului, există și circuite al căror comportament depinde de tranzițiile semnalului (activ pe //front crescător// sau //front descrescător//). Starea bistabililor, de exemplu, se modifică pe frontul crescător sau descrescător al unui semnal de ceas. În cazul acesta, blocul always@ trebuie să se execute la detecția unui astfel de front (eng. //edge-triggered//). Pentru a modela un astfel de comportament Verilog oferă cuvântul cheie **posedge** ce poate fi alăturat numelui semnalului unui semnal din lista de sensitivități pentru a indica activarea blocului //always// la un front al semnalului. De exemplu blocul ''always @(posedge clk)'' se activează pe frontul crescător al semnalului //clk//. | + | ==== Atribuiri non-blocante ==== |
| - | /*<hidden Click pentru informații adiționale despre sensitivity list> - nu mi se pare ok sa fie hidden aceasta subsectiune, ar trebui sa fie mai vizibila, mai ales pentru ca ei nu dau click pe lucrurile hidden, e considera in plus, ne-necesare*/ | ||
| - | Cuvintele cheie **posedge** (pentru front crescător) și **negedge** (pentru front descrescător) indică activarea blocului //always@ edge-triggered// la schimbarea frontului semnalului. | + | În blocurile ''always@'' din laboratoarele precedente au fost folosite atribuirile ce utilizează operatorul "=", numite //atribuiri blocante//, deoarece se execută secvențial, ca în limbajele de programare procedurale (C, Java etc). Verilog oferă și un alt tip de atribuiri, care sunt executate toate în același timp, în paralel, indiferent de ordinea lor în bloc. Pentru a descrie un astfel de comportament se folosește operatorul "<=", iar atribuirile se numesc //atribuiri non-blocante//. Acest nou tip de atribuire **modelează concurența care poate fi întâlnită în hardware la transferarea datelor între registre**. |
| - | <code verilog Exemple sensitivity list> | + | Variabilele cărora li se atribuie o valoare trebuie să fie de tip registru (//reg, integer//) atât în cazul blocant cât și în cel non-blocant. Simulatorul evaluează întâi partea dreaptă a atribuirilor și apoi atribuie valorile către partea stângă. Acest lucru face ca ordinea atribuirilor non-blocante să nu conteze, deoarece rezultatul lor va depinde de ce valori aveau variabilele din partea dreaptă înainte de execuție. |
| - | always @(posedge sig) // frontul crescator al semnalului 'sig' | + | == Exemplu atribuiri non-blocante == |
| - | always @(negedge sig) // frontul descrescator al semnalului 'sig' | + | |
| - | always @(posedge sig1, posedge sig2) // frontul crescator al semnalului 'sig1' sau frontul crescator al semnalului 'sig2' | + | |
| - | always @(posedge sig1, negedge sig2) // frontul crescator al semnalului 'sig1' sau frontul descrescator al semnalului 'sig2' | + | |
| - | + | ||
| - | </code> | + | |
| - | + | ||
| - | /*</hidden>*/ | + | |
| - | + | ||
| - | === Atribuiri non-blocante === | + | |
| - | + | ||
| - | În blocurile //always@// din laboratoarele precedente au fost folosite atribuirile cu ''='', numite //atriburi blocante//, deoarece se execută secvențial, ca în limbajele de programare procedurale (C, Java etc). Verilog oferă și un alt tip de atribuiri, care sunt executate toate în același timp, în paralel, indiferent de ordinea lor în bloc. Pentru a descrie un astfel de comportament se folosește operatorul ''<nowiki><=</nowiki>'', iar atribuirile se numesc //atribuiri non-blocante//. Acest nou tip de atribuire **modelează concurența care poate fi întâlnită în hardware la transferarea datelor între registre**. | + | |
| - | + | ||
| - | Variabilele cărora li se atribuie o valoare trebuie să fie de tip registru (//reg//, //integer//) atât în cazul blocant cât și în cel non-blocant. Simulatorul evaluează întâi partea dreaptă a atribuirilor și apoi atribuie valorile către partea stângă. Acest lucru face ca ordinea atribuirilor non-blocante să nu conteze, deoarece rezultatul lor va depinde de ce valori aveau variabilele din partea dreaptă înainte de execuție. | + | |
| - | + | ||
| - | <code verilog Exemplu atriburi non-blocante> | + | <code systemverilog> |
| - | always @(posedge sig) begin // executat pe frontul crescător al semnalului sig | + | always @(posedge sig) // executat pe frontul crescător al semnalului sig |
| + | begin | ||
| a <= b; | a <= b; | ||
| b <= a; // se interschimba valoarea lui a cu cea a lui b | b <= a; // se interschimba valoarea lui a cu cea a lui b | ||
| Line 77: | Line 50: | ||
| </code> | </code> | ||
| + | <note important>În cadrul blocurilor always care modelează logică **combinațională** se folosesc **atribuiri blocante** ("="), iar în blocurile care modelează logică **secvențială** se folosesc **atribuiri non-blocante** ("<=")</note> | ||
| - | <note important>În cadrul blocurilor always care modelează logică **combinațională** se folosesc **atribuiri blocante** (''=''), iar în blocurile care modelează logică **secvențială** se folosesc **atribuiri non-blocante** (''<nowiki><=</nowiki>'')</note> | + | ===== Bistabilul D ===== |
| - | === Bistabilul D === | + | Exemplele următoare reprezintă implementarea unui bistabil D, prezentat în laboratorul 0, care menține valoarea de intrare ("D") între două fronturi crescătoare ale semnalului de ceas ("clk"). Circuitului prezentat în laboratorul 0 i s-a adăugat și un semnal de reset ("rst_n"). Numele semnalului de reset se termină cu "_n", în mod convențional, pentru a sugera că acesta este activ pe negedge. |
| - | Exemplele următoare reprezintă implementarea unui bistabil D, prezentat în [[.:lab00#bistabilul-d|laboratorul 0]], care menține valoarea de intrare (''D'') între două fronturi crescătoare ale semnalului de ceas (''clk''). Circuitului prezentat în laboratorul 0 i s-a adăugat și un semnal de reset (''rst_n''). | + | În exemplul de mai jos, semnalul de reset este verificat **sincron**, atribuirile făcute ieșirii Q fiind **non-blocante**. Observați că operația de reset este condiționată de valoarea "0" a semnalului "rst_n". |
| - | <note tip>Numele semnalului de reset se termină cu ''_n'', în mod convențional, pentru a sugera că acesta este activ pe negedge.</note> | + | |
| - | În exemplul de mai jos, semnalul de reset este verificat **sincron**, atribuirile făcute ieșirii Q fiind **non-blocante**. Observați că operația de reset este condiționată de valoarea ''0'' a semnalului ''rst_n''. | + | |
| - | <code verilog Bistabilul D - reset verificat sincron> | + | == Bistabilul D - reset verificat sincron == |
| + | <code systemverilog> | ||
| module D_flip_flop(output reg Q, input D, clk, rst_n); | module D_flip_flop(output reg Q, input D, clk, rst_n); | ||
| Line 100: | Line 73: | ||
| endmodule | endmodule | ||
| - | |||
| </code> | </code> | ||
| Verificarea resetului se poate realiza și în mod asincron. | Verificarea resetului se poate realiza și în mod asincron. | ||
| - | <hidden Click pentru informații adiționale despre always asincron> | + | == Informații adiționale despre always asincron == |
| - | În cel de-al doilea exemplu, semnalul este verificat **asincron**. Modulul este sintetizabil și are un comportament asemănător cu modulul asincron din al treilea exemplu. Pentru a fi sintetizabil este necesar ca toate atribuirile asupra registrului Q să fie realizate în acelasi bloc //always//, iar blocul //always// să fie activat pe //frontul crescător// al semnalului //clk// sau pe //frontul crescător// al semnalului //!rst_n//. | + | |
| - | <code verilog Bistabilul D - reset verificat asincron (modul sintetizabil)> | + | În cel de-al doilea exemplu, semnalul este verificat **asincron**. Modulul este sintetizabil și are un comportament asemănător cu modulul asincron din al treilea exemplu. Pentru a fi sintetizabil este necesar ca toate atribuirile asupra registrului Q să fie realizate în același bloc //always//, iar blocul //always// să fie activat pe //frontul crescător// al semnalului //clk// sau pe //frontul crescător// al semnalului //!rst_n//. |
| + | == Bistabilul D - reset verificat asincron == | ||
| + | |||
| + | <code systemverilog> | ||
| module D_flip_flop(output reg Q, input D, clk, rst_n); | module D_flip_flop(output reg Q, input D, clk, rst_n); | ||
| always @(posedge clk or negedge rst_n) begin | always @(posedge clk or negedge rst_n) begin | ||
| if(!rst_n) | if(!rst_n) | ||
| - | Q <= 0; | + | Q <= 0; |
| else | else | ||
| - | Q <= D; | + | Q <= D; |
| end | end | ||
| + | |||
| endmodule | endmodule | ||
| - | |||
| </code> | </code> | ||
| - | |||
| <note important>Un **modul** este **nesintetizabil** dacă acesta conține atribuiri asupra aceluiași registru în mai mult de un bloc **always**.</note> | <note important>Un **modul** este **nesintetizabil** dacă acesta conține atribuiri asupra aceluiași registru în mai mult de un bloc **always**.</note> | ||
| + | În cel de-al treilea exemplu, este prezentat cazul în care semnalul de reset este verificat **asincron**, iar atribuirile făcute ieșirii Q sunt **blocante** în cazul în care semnalul "!rst_n" devine 1 logic sau **non-blocante** pe frontul crescător al semnalului "clk". În acest caz, se obține un modul nesintetizabil. | ||
| - | În cel de-al treilea exemplu, este prezentat cazul în care semnalul de reset este verificat **asincron**, iar atribuirile făcute ieșirii Q sunt **blocante** în cazul în care semnalul ''!rst_n'' devine 1 logic sau **non-blocante** pe frontul crescător al semnalului ''clk''. În acest caz, se obține un modul nesintetizabil. | + | == Bistabilul D - reset verificat sincron (modul nesintetizabil) == |
| - | <code verilog Bistabilul D - reset verificat asincron (modul nesintetizabil)> | + | <code systemverilog> |
| - | + | ||
| - | module D_flip_flop(output reg Q, input D, clk, rst_n); | + | |
| - | + | ||
| always @(posedge clk) begin | always @(posedge clk) begin | ||
| if(rst_n) | if(rst_n) | ||
| Line 140: | Line 110: | ||
| always @(*) begin | always @(*) begin | ||
| if(!rst_n) | if(!rst_n) | ||
| - | Q = 0; | + | Q <= 0; |
| end | end | ||
| endmodule | endmodule | ||
| - | |||
| </code> | </code> | ||
| - | </hidden> | + | ===== Automate finite ===== |
| - | ==Automate finite== | + | |
| - | Automatele finite (eng. Finite-state machine - FSM), amintite în [[.:lab00#automate-finite|laboratorul 0]], sunt implementate prin logică secvențială. Știind comportamentul unui anumit automat, îl putem implementa folosind două blocuri always@ care să modeleze partea de stare și, respectiv, logica combinațională a acestuia. | ||
| - | <note important> | + | Automatele finite (eng. Finite State machine - FSM), amintite în laboratorul 0, sunt implementate prin logică secvențială. Știind comportamentul unui anumit automat, îl putem implementa folosind două blocuri always@ care să modeleze partea de stare și, respectiv, logica combinațională a acestuia. |
| - | + | ||
| - | Elementele de memorare (stare) ale circuitului se modelează printr-un bloc activ pe frontului semnalului de ceas. | + | |
| - | + | ||
| - | În blocul combinațional trebuie tratate toate stările posibile ale automatului, semnalele de ieșire și tranzițiile din aceste stări. | + | |
| - | + | ||
| - | </note> | + | |
| - | <code verilog> | + | <note important>Elementele de memorare (stare) ale circuitului se modelează printr-un bloc activ pe frontului semnalului de ceas. În blocul combinațional trebuie tratate toate stările posibile ale automatului, semnalele de ieșire și tranzițiile din aceste stări.</note> |
| + | <code systemverilog> | ||
| module fsm(output reg out, input in, clk, reset_n); | module fsm(output reg out, input in, clk, reset_n); | ||
| reg [2:0] state, next_state; | reg [2:0] state, next_state; | ||
| - | // partea secventiala | + | // partea secvențială |
| always @(posedge clk) begin | always @(posedge clk) begin | ||
| if (reset_n == 0) state <= 0; | if (reset_n == 0) state <= 0; | ||
| Line 190: | Line 152: | ||
| end | end | ||
| endmodule | endmodule | ||
| - | |||
| </code> | </code> | ||
| - | <note warning> | + | <note important>Nu combinați blocurile secvențiale cu cele combinaționale (e.g. "always @(posedge clk, state, in)") deoarece majoritatea utilitarelor nu vor sintetiza corect un astfel de circuit. |
| - | Nu combinați blocurile secvențiale cu cele combinaționale (e.g. ''always @(posedge clk, state, in)'') deoarece majoritatea utilitarelor nu vor sintetiza corect un astfel de circuit. | + | </note> |
| - | </note> | + | |
| + | |||
| + | ==== Expresii regulate ==== | ||
| - | == Expresii Regulate == | ||
| Expresiile Regulate sunt secvențe de caractere ce definesc un tipar de căutare, folosite în multe cazuri pentru identificarea șirurilor sau sub-șirurilor de caractere ce se potrivesc cu expresia. | Expresiile Regulate sunt secvențe de caractere ce definesc un tipar de căutare, folosite în multe cazuri pentru identificarea șirurilor sau sub-șirurilor de caractere ce se potrivesc cu expresia. | ||
| Cea mai simplă metodă de vizualizare a unei expresii regulate este prin intermediul Automatelor Finite de stări. | Cea mai simplă metodă de vizualizare a unei expresii regulate este prin intermediul Automatelor Finite de stări. | ||
| - | Pentru a descrie un tipar care conține un sub-șir între zero și nelimitate ori, este utilizat cuantificatorul ''*'', iar pentru a descrie un tipar care conține un sub-șir intre una și nelimitate ori, este utilizat cuantificatorul ''+''. | ||
| - | Parantezele ''('' '')'' sunt folosite pentru a delimita grupuri de caractere. Dacă acestea nu sunt specificate, cuantificatorul va avea efect asupra caracterului anterior. | ||
| - | <code> | ||
| - | Exemple: | ||
| - | a(bc)* - se va potrivi cu șirurile de caractere 'a', 'abc', 'abcbc', 'abcbcbc', etc. | ||
| - | (ab)+c - se va potrii cu șirurile de caractere 'abc', 'ababc', 'abababc', etc. | ||
| - | ab+a - se va potrivi cu șirurile de caractere 'aba', 'abba', 'abbba', etc. | ||
| + | Pentru a descrie un tipar care conține un sub-șir între zero și nelimitate ori, este utilizat cuantificatorul "*", iar pentru a descrie un tipar care conține un sub-șir între una și nelimitate ori, este utilizat cuantificatorul "+". | ||
| + | |||
| + | Parantezele "(" ")" sunt folosite pentru a delimita grupuri de caractere. Dacă acestea nu sunt specificate, cuantificatorul va avea efect asupra caracterului anterior. | ||
| + | |||
| + | == Exemple: == | ||
| + | |||
| + | <code> | ||
| + | a(bc)* - se va potrivi cu șirurile de caractere 'a', 'abc', 'abcbc', 'abcbcbc' etc. | ||
| + | (ab)+c - se va potrivi cu șirurile de caractere 'abc', 'ababc', 'abababc' etc. | ||
| + | ab+a - se va potrivi cu șirurile de caractere 'aba', 'abba', 'abbba' etc. | ||
| </code> | </code> | ||
| - | <note important>Nu confundați operatorii ''*'' și ''+'' cu înmulțire și adunare. În contextul expresiilor regulate, aceștia sunt folosiți pentru a descrie tipare de căutare și nu sunt folosiți pentru a scrie cod Verilog.</note> | + | <note important>Nu confundați operatorii "*" și "+" cu înmulțire și adunare. În contextul expresiilor regulate, aceștia sunt folosiți pentru a descrie tipare de căutare și **NU** sunt folosiți pentru a scrie cod Verilog. |
| + | </note> | ||
| + | |||
| + | |||
| + | ===== Debouncing ===== | ||
| - | == Debouncing == | ||
| Atunci când un buton este apăsat sau un switch este comutat, două părți metalice intră în contact pentru a permite curentului să treacă. Cu toate acestea, ele nu se conectează instantaneu, ci se conectează și deconectează de câteva ori înainte de realizarea conexiunii propriu-zise. Același lucru se întâmplă și în momentul eliberării unui buton (când acesta nu mai este apăsat). Acest fenomen poate conduce la comutări false sau modificări multiple nedorite asupra semnalului și este denumit **bouncing**. | Atunci când un buton este apăsat sau un switch este comutat, două părți metalice intră în contact pentru a permite curentului să treacă. Cu toate acestea, ele nu se conectează instantaneu, ci se conectează și deconectează de câteva ori înainte de realizarea conexiunii propriu-zise. Același lucru se întâmplă și în momentul eliberării unui buton (când acesta nu mai este apăsat). Acest fenomen poate conduce la comutări false sau modificări multiple nedorite asupra semnalului și este denumit **bouncing**. | ||
| - | Prin urmare, se poate spune că fenomenul de "bouncing" nu este un comportament ideal pentru niciun switch care execută mai multe tranziții ale unuei singure intrări. Aceasta nu este o problemă majoră când avem de-a face cu circuite de putere, dar poate cauza probleme atunci când avem de-a face cu circuitele logice sau digitale. Așadar, pentru a elimina oscilațiile din semnal cauzate de acest fenomen se folosește principiul de **Switch Debouncing**. | ||
| - | Procedeul de debouncing este întâlnit, de asemenea și în software. | ||
| - | Urmăriți în scheletul de cod din exercițiul 1 cum este implementat un debouncer și analizați comportamentul acestuia. | ||
| - | == Exerciții == | + | Prin urmare, se poate spune că fenomenul de "bouncing" nu este un comportament ideal pentru niciun switch care execută mai multe tranziții ale unei singure intrări. Aceasta nu este o problemă majoră când avem de-a face cu circuite de putere, dar poate cauza probleme atunci când avem de-a face cu circuitele logice sau digitale. Așadar, pentru a elimina oscilațiile din semnal cauzate de acest fenomen se folosește principiul de **Switch Debouncing**. |
| - | - Se dorește proiectarea unui automat finit capabil să recunoască secvențe care se potrivesc cu expresia regulată ''ab+a''. Automatul primește la intrare în mod continuu caractere codificate printr-un semnal de un bit (caracterele posibile sunt “a” și “b”). Ieșirea automatului va consta dintr-un semnal care va fi activat (valoarea 1) atunci când la intrare am avut prezent un șir care se potrivește cu tiparul de căutare. | + | Procedeul de debouncing este întâlnit, de asemenea și în software. Urmăriți în scheletul de cod din exercițiul 1 cum este implementat un debouncer și analizați comportamentul acestuia. |
| - | - (**2p**) Implementați automatul în Verilog. | + | |
| - | * Hint: Realizați pe hârtie schema automatului de stări, pentru a o folosi ulterior ca referință. | + | |
| - | * Hint: Observați în [[.:lab00#recunoasterea-secventei-ba | laboratorul 0]] strategia abordată pentru implementarea unui automat ce recunoaște o secvență de caractere. | + | |
| - | - (**2p**) Simulați automatul folosind modulul de test din scheletul de cod. Eliminați semnalele nerelevante (//is// și //count//) din diagrama de semnale. Adăugați starea automatului și starea următoare a automatului la diagrama de semnale. | + | |
| - | * Hint: Semnalele pot fi eliminate din diagrama de semnale cu //click-dreapta->Delete// pe semnalul care se dorește a fi eliminat. | + | |
| - | * Hint: Semnale noi pot fi adăugate la diagrama de semnale prin //drag-and-drop// din fereastra //Simulation Objects for ...//, care conține toate semnalele modulului selectat în fereastra //Instance and Process Name//. | + | |
| - | * Hint: Simularea trebuie repornită prin //Simulation->Restart// urmat de //Simulation->Run// pentru a vedea comportamentul semnalelor adăugate. | + | |
| - | - (**2p**) Urmăriți diagrama de semnale și codul automatului și explicați comportamentul. Urmăriți și explicați funcționarea modulului de test. | + | |
| - | - (**1p**) Testați implementarea circuitului pe placa de laborator. | + | |
| - | - Se dorește modelarea prin intermediul unui automat de stări a unei intersecții semaforizate în care mașinile pot intra din nord (N), est (E), sud(S) sau vest (W). Semaforul din nord este sincronizat cu semaforul din sud, iar cel din est este sincronizat cu cel din vest. Duratele de timp pentru cele două direcții vor fi: Nord - Sud: roșu - 40 sec, galben - 10sec, verde - 50sec; Est-Vest: roșu - 60 sec, galben - 10 sec, verde - 30 sec. | + | |
| - | - (**3p**) Implementați și simulați în Verilog automatul necesar. Ce rol are modulul //intersecție// din fișierul //intersectie.v//? | + | |
| - | * Hint: Consultați [[.:lab00#intersectie-semaforizata | laboratorul 0]] pentru diagrama de tranziție a unui astfel de automat. | + | |
| - | - (**1p**) Testați implementarea circuitului pe placa de laborator. | + | |
| - | - (**1p**) Explicați codul numărătorului din fișierul //counter.v//. | + | |
| - | * Hint: Urmăriți comportarea acestuia pe diagrama de semnale. | + | |
| - | == Resurse == | + | ===== Exerciții ===== |
| - | * {{.:lab04:lab4_skel.zip|Schelet de cod}} | + | |
| - | * {{.:lab04:sol:lab4_sol.zip|Soluție laborator}} (disponibilă începând cu 26.10.2019) | + | |
| - | * <html><a class="media mediafile mf_pdf" href="/ac/wiki/lab/lab04?do=export_pdf">PDF laborator</a></html> | + | |
| - | <ifauth @user> | + | - Se dorește proiectarea unui automat finit capabil să recunoască secvențe de tip "ba". Automatul primește la intrare în mod continuu caractere codificate printr-un semnal de un bit (caracterele posibile sunt "a" și "b"). Ieșirea automatului va consta dintr-un semnal care va fi activat (valoarea 1) atunci când la intrare am avut prezent un șir care se potrivește cu tiparul de căutare. |
| + | - Implementați automatul în Verilog. | ||
| + | * //Hint//: Realizați pe hârtie schema automatului de stări, pentru a o folosi ulterior ca referință. | ||
| + | * //Hint//: Observați în [[ac-is:lab:lab00|laboratorul 0]] strategia abordată pentru implementarea unui automat ce recunoaște o secvență de caractere. | ||
| + | - Simulați automatul folosind modulul de test din scheletul de cod. Eliminați semnalele nerelevante (//is// și //count//) din diagrama de semnale. Adăugați starea automatului și starea următoare a automatului la diagrama de semnale. | ||
| + | * //Hint//: Semnalele pot fi eliminate din diagrama de semnale cu //click dreapta->Delete// pe semnalul care se dorește a fi eliminat. | ||
| + | * //Hint//: Semnale noi pot fi adăugate la diagrama de semnale prin //drag-and-drop// din fereastra //Simulation Objects for ...//, care conține toate semnalele modulului selectat în fereastra //Instance and Process Name//. | ||
| + | * //Hint//: Simularea trebuie repornită prin //Simulation->Restart// urmat de //Simulation->Run// pentru a vedea comportamentul semnalelor adăugate. | ||
| + | - Urmăriți diagrama de semnale și codul automatului și explicați comportamentul. Urmăriți și explicați funcționarea modulului de test. | ||
| + | - Se dorește realizarea unei treceri de pietoni semaforizate. Duratele de timp pentru cele 2 culori vor fi: roșu - 60 sec, verde - 30 sec. | ||
| + | - Implementați și simulați în Verilog automatul necesar. Ce rol are modulul //trecere// din fișierul //trecere.v//? | ||
| + | * //Hint//: Consultați [[ac-is:lab:lab00|laboratorul 0]] pentru diagrama de tranziție a unui automat similar și propuneți o diagramă de tranziție pretabilă cerinței noastre | ||
| + | - Explicați codul numărătorului din fișierul //counter.v//. | ||
| + | * //Hint//: Urmăriți comportarea acestuia pe diagrama de semnale. | ||
| + | |||
| + | |||
| + | ===== Resurse ===== | ||
| + | * {{.:lab04:lab4_skel.zip|Schelet de cod}} | ||
| + | * <html><a class="media mediafile mf_pdf" href="https://ocw.cs.pub.ro/courses/ac-is/lab/lab04?do=export_pdf">PDF laborator</a></html> | ||
| + | * {{.:lab04:sol:lab4_sol.zip|Soluție laborator}} | ||
| + | |||
| + | <ifauth @ac-is> | ||
| ---- | ---- | ||
| - | * [[:internal:seq|Ghid asistent]] | + | * {{.:lab04:sol:lab4_sol.zip|Soluție laborator}} |
| + | * [[ac-is:internal:guidelines|Ghid asistent]] | ||
| </ifauth> | </ifauth> | ||
| + | |||
