Show page

Differences

This shows you the differences between two versions of the page.

--- ac-is:lab:lab01 [2021/09/20 22:19]
ionut.pascal old revision restored (2021/09/20 18:36)
+++ ac-is:lab:lab01 [2023/10/21 14:50] (current)
teodor.dicu [Resurse]
@@ Line 1: / Line 1: @@
-= Laboratorul 1 - Limbajul Verilog: Introducere =
+====== Laboratorul 1 -  Introducere in Verilog. Descrierea structurala ======
-== Verilog ==
+===== Verilog =====
-În cadrul laboratorului de Arhitectura Calculatoarelor vom studia un limbaj de descriere a hardware-ului (eng. //Hardware Description Language - HDL//) numit **Verilog**. Limbajele de descriere a hardware-ului sunt folosite în industrie pentru proiectarea și implementarea circuitelor digitale (eng. //Aplication-Specific Integrated Circuit - ASIC//). Cele mai folosite limbaje de descriere a hardware-ului sunt Verilog și VHDL. Din punct de vedere al sintaxei ele se aseamănă cu limbajele de programare de uz general (ex. C/C++/Java) însă oferă în plus anumite facilități pentru modelarea și simularea logicii combinaționale și secvențiale.
+În cadrul laboratorului de Arhitectura Calculatoarelor vom studia un limbaj de descriere a hardware-ului (//eng. Hardware Description Language - **HDL**//) numit **Verilog**. Îl vom folosi pe tot parcursul laboratorului pentru a implementa noțiuni legate de arhitectura calculatoarelor.
+Limbajele de descriere a hardware-ului sunt folosite în industrie pentru proiectarea și implementarea circuitelor digitale. Cele mai folosite limbaje de descriere a hardware-ului sunt **Verilog** și **VHDL**.
-Proiectarea unui circuit digital într-un HDL începe printr-o descriere textuală a circuitului. Aceasta este compilată pentru a verifica sintaxa și a genera un model al circuitului iar apoi modelul poate fi rulat într-un simulator pentru a verifica funcționalitatea descrierii. O alternativă la rularea în simulator este sintetizarea unei configurații pentru programarea unui chip FPGA și testarea acestuia.
+Deși din punct de vedere sintactic se aseamănă foarte mult cu un limbaj de programare de uz general (C/C++/Java), trebuie ținut cont că instrucțiunile nu se execută secvențial, ca pe un procesor. Ținta unui cod scris în Verilog este implementarea sa pe un **FPGA** sau dezvoltarea unui **ASIC** (Application Specific Integrated Circuit).
-Verilog oferă mai multe alternative pentru descrierea unui circuit. Două dintre aceste alternative pe care le vom folosi în cadrul laboratorului sunt:
- * **descrierea structurală** - porțile logice sunt legate între ele, asemănător cu o schemă logică, pentru a obține funcționalitatea dorită; aceasta este subiectul pe care îl vom aborda în laboratorul de față.
- * **descrierea comportamentală** - se folosesc construcțiile de nivel înalt (ex. ''if'', ''for'', ''while'' etc.) pentru a descrie funcționalitatea dorită; vom aborda acest subiect în laboratoarele viitoare.
+==== De ce Verilog? ====
-=== Primitive ===
-Pentru descrierea structurală a circuitelor, Verilog oferă o serie de primitive (eng. //built-in primitives//) asociate porților logice de bază (nu există primitive secvențiale predefinite). O listă abreviată a primitivelor predefinite poate fi consultată în <tabref tabel-primitive>.
+Un limbaj de descriere hardware conține o serie de abstractizări sau moduri de a genera, prin intermediul codului, porți logice. În comparație cu a proiecta “de mână” circuitele integrate, tocmai aceste abstractizări sunt cele care au permis electronicii digitale să se dezvolte în ritm rapid, odată cu progresul tehnologiei de fabricație. Cu ajutorul lor putem descrie relativ ușor structuri complexe, divizându-le în componentele lor comune și de bază.
-<tabcaption tabel-primitive center |Primitive Verilog>
+Însă apare întrebarea naturală: Ce aș putea face cu un FPGA și nu aș putea face cu un procesor? Pe scurt, există trei răspunsuri:
+  * Un FPGA poate fi reconfigurat într-un timp foarte scurt. Asta înseamnă că, dacă am greșit ceva în design-ul nostru, dacă dorim să-l modificăm sau să-l extindem, timpul și costul acestei acțiuni sunt foarte mici;
+  * Un FPGA, prin construcția lui, oferă un grad extrem de ridicat de paralelism, lucru pe care codul scris pentru un procesor (deci cod secvențial) îl oferă într-o măsură mai redusă și mai greu de controlat;
+  * Un FPGA este de preferat oricând se dorește interfațarea unui dispozitiv (un senzor, un dispozitiv de afișare, etc.) care are nevoie de timpi foarte stricți în protocolul de comunicatie (exemplu: așteaptă 15 nanosecunde înainte să schimbi linia de ceas, apoi activează linia de enable pentru 25 de nanosecunde, apoi pune datele pe linia de date și ține-le cel puțin 50 de nanosecunde, etc). Pe un procesor acest lucru este iarăși dificil de controlat, fiindcă majoritatea instrucțiunilor se execută într-un număr diferit de cicli de ceas.
-^  N intrări  ^  N ieșiri  ^
+Întrucât au fost puse în discuție atât proiectarea prin porți logice a unui circuit cât și descrierea lui la un nivel mai abstract, putem clasifica alternative de descriere a unui circuit:
-|  or         |  buf       |
+  * **descrierea structurală** - mai puțin folosită, ea reprezintă o implementare asemănătoare cu o schemă logică a unui circuit, folosind primitive și module pentru implementarea funcționalității
-|  and        |  not       |
+  * **descrierea comportamentală** - divizată în descriere la nivel de flux de date și descriere la nivel procedural, folosește construcții de nivel înalt, întâlnite și în alte limbaje de programare.
-|  nor        |            |
-|  nand       |            |
-|  xor        |            |
-|  xnor       |            |
-</tabcaption>
-Fiecare primitivă are porturi, prin care este conectată în exterior. Primitivele predefinite oferă posibilitatea conectării mai multor intrări (ex. or, and, xor etc.) sau mai multor ieșiri (ex. buf, not). Folosirea unei primitive se face prin instanțierea cu lista de semnale care vor fi conectate la porturile ei. Pentru primitivele predefinite porturile de ieșire sunt declarate înaintea porturilor de intrare.
+==== Ce tipuri de circuite putem construi? ====
-<tabref tabel-instantiere> oferă câteva exemple de instanțiere a unor porți în Verilog. Pentru primitivele predefinite numele instanței este opțional.
-<tabcaption tabel-instantiere center |Exemple de instanțiere a primitivelor>
+**Circuitele logice combinaționale** aplică funcții logice pe intrări pentru a obține ieșirile. Valorile de ieșire depind astfel doar de valorile curente de intrare, iar când starea unei intrări se schimbă, se reflectă imediat asupra ieșiri.
-^  Schema  ^  Cod  ^
+{{ :ac-is:lab:lab00:circuit-comb.png |Diagrama bloc pentru un circuit combinațional cu n intrări și m ieșiri}}
-|  {{ .:lab01:or-gate.png?210 |}}         |  <code verilog>or(out, a, b, c);
+<html><p align="center">Diagrama bloc pentru un circuit combinațional cu n intrări și m ieșiri</p></html>
-// sau
-or o1(out, a, b, c);</code>  |
-|  {{ .:lab01:not-gate.png?250 |}}        |  <code verilog>not(out, in);
-// sau
-not my_not(out, in);</code>    |
-|  {{ .:lab01:nand-gate.png?210 |}}       |  <code verilog>nand (z, x, y);
-// sau
-nand n(z, x, y);</code>  |
-</tabcaption>
+Logica combinațională poate fi reprezentată prin:
+  * diagrame structurale la nivel de porți logice,
+  * tabele de adevăr,
+  * expresii booleene (funcții logice).
+Spre deosebire de **circuitele** logice combinaționale, cele **secvențiale** (eng: sequential logic) nu mai depind exclusiv de valoarea curentă a intrărilor, ci și de stările anterioare ale circuitului. Logica secvențială poate fi de două tipuri: sincronă și asincronă.
-=== Wires ===
+{{ :ac-is:lab:lab00:circuit-secv.png?400 |Schema bloc a unui circuit secvențial sincron}}
+<html><p align="center">Schema bloc a unui circuit secvențial sincron</p></html>
-În Verilog, specificarea semnalelor dintr-o diagramă structurală se face prin **wires**. Acestea se declară prin cuvântul cheie ''wire''.
+În primul caz, cel cu care vom lucra și la laborator, este folosit un semnal de ceas care comandă elementul/elementele de memorare, acestea schimbându-și starea doar la impulsurile de ceas. În al doilea caz, ieșirile se modifică atunci când se modifică și intrările, neexistând un semnal de ceas pentru elementele de memorare. Circuitele secvențiale asincrone sunt mai greu de proiectat, pot apărea probleme de sincronizare și sunt folosite mai rar. În continuare ne vom referi doar la circuitele secvențiale sincrone.
-|  {{ .:lab01:gates.png?400&nolink |}}  |  <code verilog>wire y1, y2;
+Pentru mai multe detalii și exemple privind circuitele combinaționale și secvențiale, studiați [[ac-is:lab:lab00|Laboratorul 0]].
-xor(out, y1, y2);
-and(y1, in1, in2);
-nand(y2, in3, in4, in5);
-</code>  |
-În exemplul anterior //y1// și //y2// sunt niște semnale de câte 1 bit care leagă ieșirile porților //and// (//y1//) și //nand// (//y2//) la intrările porții //xor//.
+În laboratorul curent ne vom concentra asupra asimilării acestui nou limbaj, începând cu **descrierea structurală a unui circuit combinațional**.
-Pentru a declara semnale pe mai mulți biți se pot folosi vectori precum în declarațiile următoare; //x// reprezintă un semnal de 8 biți, iar //y// reprezintă un semnal de 5 biți. Bitul cel mai semnificativ (eng.// most significant bit// - MSB) este situat întotdeauna în stânga, iar bitul cel mai puțin semnificativ (eng.  //least significant bit// - LSB) în dreapta.
-<code verilog>
+===== Structura limbajului Verilog ======
-wire[7:0] x;              // 8 biti, MSB este bitul 7, LSB bitul 0
-wire[0:4] y;              // 5 biti, MSB este bitul 0, LSB bitul 4
-// vector de wires
+Atunci când proiectăm un circuit digital folosind un HDL, începem prin a face o descriere textuală a circuitului, adică scriem cod. Acesta este compilat, iar în urma procesului va rezulta un model al circuitului care poate fi apoi rulat într-un simulator cu scopul de a verifica funcționalitatea descrierii. O alternativă la simulare este folosirea unui utilitar de sintetizare, care preia codul HDL și generează fișiere de configurare pentru FPGA.
-wire[7:0] a[9:0];         // vector cu 10 elemente a câte 8 biti
-// matrice de wires
+Însă proiectarea circuitelor poate deveni complexă. Datorită acestui motiv, se preferă proiectarea de tip top-down, o modalitate de partiționare sistematică și repetată a unui sistem complex în unități funcționale mai simple, a căror implementare poate fi făcută mai facil. O partiționare și organizare la nivel înalt a unui sistem reprezintă arhitectura acestuia. Unitățile funcționale individuale ce rezultă în urma partiționării sunt mai ușor de proiectat și de testat decât întregul sistem. Strategia divide-et-impera a proiectării top-down ne permite proiectarea de circuite care conțin milioane de porți.
-wire[3:0] b[4:0][4:0];    // matrice de 5x5 elemente a câte 4 biti
-</code>
-<note important>În mod implicit semnalele care nu sunt declarate sunt considerate ca fiind de tip //wire// și având 1 bit (ex. ''in1'', ''in2'', ... din codul de mai sus).</note>
+==== Module ====
-Putem accesa individual biții dintr-un wire (ex. ''x[0]'') sau într-un interval ca în limbajul Matlab (ex. ''x[3:1]'', ''x[7:2]'').
-<code verilog>
+Modulul este unitatea de bază a limbajului Verilog, element ce încapsulează inferfața și comportamentul unui circuit. Modelul //black-box// este cel mai apropiat de definiția unui modul, întrucât se cunosc elementele de legătură: intrările și ieșirile din modul precum și funcționalitatea precisă a modulului, cu un accent mai redus asupra detaliilor de implementare și a modului în care acesta funcționează.
-wire[7:0] x;         // 8 biti
+Pentru declararea unui modul, se folosesc cuvintele cheie ''module'' și ''endmodule''. Pe lângă aceste cuvinte cheie, declarația unui modul mai conține:
-wire[4:0] y;         // 5 biti
+  * numele acestuia,
+  * lista de porturi (pentru interfața cu exteriorul): pot fi de intrare (input), ieșire (output) sau intrare - ieșire (inout) și pot avea unul sau mai mulți biți,
+  * și, desigur, implementarea funcționalității modulului.
-assign x[7:3] = y;   // bitii 7-3 din x o să fie egali cu biții din y
+<note important>Ordinea porturilor unui modul nu este restricționată. Intrările și ieșirile pot fi declarate în orice ordine, însă, pentru consistență, o regulă de bună practică este folosirea convenției (obligatorie la primitive): prima dată se declară ieșirile, apoi intrările.
+</note>
-</code>
+== Exemplu declarare modul ==
+<code systemverilog>
-=== Module ===
+module my_beautiful_module (
+    output out,
-Limbajul Verilog necesită ca toate elementele prezentate anterior (primitive și wires) să fie declarate într-un **modul**. Scopul modulului este să definească interfața și să încapsuleze funcționalitatea unui circuit.
+    input [3:0] a,
+    input b);
-Pentru a declara un modul se folosesc cuvintele cheie ''module'' și ''endmodule''. Pe lângă aceste cuvinte cheie, declarația unui modul mai conține:
+/* descrierea funcționalității */
- * numele acestuia
- * lista de porturi (pentru interfața cu exteriorul); pot fi porturi de intrare (''input''), porturi de ieșire (''output'') sau porturi de intrare-ieșire (''inout'') și pot avea mai mulți biți
-<code verilog Exemplu declarare modul>
-module exemplu(output o, input a, input[3:0] b);
-    // descrierea functionalitatii
 endmodule
 </code>
-<hidden Click pentru un mod alternativ de declarare a unui modul>
+Pentru implementarea modului avem la dispoziție câteva elemente, care sunt descrise în ceea ce urmează.
-<code verilog Exemplu declarare modul în Verilog 1995)>
-module exemplu(o, a, b);
-output o;
-input a;
-input[3:0] b;
-    // descrierea functionalitatii
-endmodule
-</code>
+==== Primitive ====
-</hidden>
-Spre deosebire de primitive, ordinea porturilor unui modul nu este restricționată. Intrările și ieșirile pot fi declarate în orice ordine, însă, pentru consistență, se preferă folosirea convenției de la primitive: prima dată se declară ieșirile, apoi intrările.
-Implicit, toate porturile sunt de tip //wire//, însă acest lucru poate fi modificat pentru porturile de ieșire (porturile de intrare nu pot fi modificate). Vom discuta acest aspect în laboratoarele următoare.
+Element ce stă la baza descrierii structurale a circuitelor, primitiva este o funcție asociată unei porți logice de bază. Verilog are o suită de primitive predefinite:
+  * primitive asociate porților logice: and, or, nand, nor, xor, xnor;
+  * primitive asociate porților de transmisie: not, buf, etc;
+  * primitive asociate tranzistorilor: pmos, tranif, etc.
+Fiecare primitivă are porturi, prin care este conectată în exterior. Primitivele predefinite oferă posibilitatea conectării mai multor intrări (ex. or, and, xor etc.) sau mai multor ieșiri (ex. buf, not). Folosirea unei primitive se face prin instanțierea sa cu lista de semnale care vor fi conectate la porturile ei. Pentru primitivele predefinite porturile de ieșire sunt declarate **înaintea** porturilor de intrare.
-=== Instanțiere module ===
+Tabelul de mai jos oferă câteva exemple de instanțiere a unor porți în Verilog. Pentru primitivele predefinite numele instanței este opțional.
-Descrierea funcționalității unui modul poate folosi, pe lângă primitive, și instanțe ale altor module. Acest lucru se face asemănător cu instanțierea unei primitive, cu diferența că, în acest caz, numele instanței **nu** este opțional.
+^  Schema  ^  Cod  ^
+|  {{ .:lab01:or-gate.png?210 |}}         |  <code verilog>or(out, a, b, c);
+// sau
+or o1(out, a, b, c);</code>  |
+|  {{ .:lab01:not-gate.png?250 |}}        |  <code verilog>not(out, in);
+// sau
+not my_not(out, in);</code>    |
+|  {{ .:lab01:nand-gate.png?210 |}}       |  <code verilog>nand (z, x, y);
+// sau
+nand n(z, x, y);</code>  |
-<code verilog Exemplu instanțiere modul>
+<html><p align="left">Exemple de instanțiere a primitivelor</p></html>
-module mux4_1(output out, input[3:0] in, input[1:0] sel);
-    // implementare multiplexor 4:1
-endmodule
-module mux8_1(output out, input[7:0] in, input[2:0] sel);
+==== Wires ====
-    mux4_1 m1(out30, in[3:0], sel[1:0]);    // instantiere mux4_1
-    mux4_1 m2(out47, in[7:4], sel[1:0]);    // alta instantiere mux4_1
-    // logica aditionala
-    not(n_sel2, sel[2]);
-    and(y1, out30, n_sel2);
-    and(y2, out47, sel[2]);
-    or(out, y1, y2);
-endmodule
-</code>
-În exemplul anterior definiția modulului //mux8_1// folosește instanțe ale modulului //mux4_1//, denumite //m1// și //m2//. Semnalele //out30//, //in[3:0]// și //sel[1:0]// sunt legate la porturile //out//, //in// și, respectiv, //sel// ale instanței //m1//, asemănător cu apelul unei funcții în C.
+Un singur modul sau o singură primitivă nu poate îndeplini singură funcția cerută. Astfel, apare necesitatea interconectării modulelor sau a primitivelor. Specificarea semnalelor dintr-o diagramă se face prin **wires**, care se declară prin cuvântul cheie ''wire''.
-<imgcaption mux81 center |Multiplexorul 8:1>{{.:lab01:mux81.png?600|}}</imgcaption>
-<hidden Click pentru un mod alternativ de instanțiere a unui modul>
+|  {{ .:lab01:gates.png?400&nolink |}}  |  <code verilog>wire y1, y2;
+xor(out, y1, y2);
+and(y1, in1, in2);
+nand(y2, in3, in4, in5);
+</code>  |
+<html><p align="left"></p></html>
-În Verilog, legătura dintre porturile unei instanțe și semnalele legate la aceste porturi poate fi făcută și pe baza numelor, nu doar a poziției. Această metodă de instanțiere a unui modul poate fi observată în exemplul următor.
-<code verilog Exemplu instanțiere modul>
+În exemplul anterior y1 și y2 sunt semnale de câte 1 bit care leagă ieșirile porților and (y1) și nand (y2) la intrările porții xor.
-module mux4_1(output out, input[3:0] in, input[1:0] sel);
+Pentru a declara semnale pe mai mulți biți se pot folosi vectori precum în declarațiile următoare: m reprezintă un semnal de 8 biți, iar n reprezintă un semnal de 5 biți. Bitul cel mai semnificativ (eng. most significant bit - MSB) este situat întotdeauna în stânga, iar bitul cel mai puțin semnificativ (eng. least significant bit - LSB) în dreapta.
-    // implementare multiplexor 4:1
-endmodule
-module mux8_1(output out, input[7:0] in, input[2:0] sel);
+În mod implicit semnalele care nu sunt declarate sunt considerate ca fiind de tip wire și având 1 bit (ex. in1, in2, … din codul de mai sus). Putem accesa individual biții dintr-un wire sau putem accesa un grup consecutiv de biți specificând intervalul (ex. m[0], m[3:1], m[7:2]).
-    mux4_1 m1(.out(out30), .in(in[3:0]), .sel(sel[1:0]));   // instantiere mux4_1
-    mux4_1 m2(.sel(sel[1:0]), .in(in[7:4]), .out(out74));   // alta instantiere mux4_1
-    // logica aditionala
-    not(n_sel2, sel[2]);
-    and(y1, out30, n_sel2);
-    and(y2, out74, sel[2]);
-    or(out, y1, y2);
-endmodule
+<code systemverilog>
+wire[7:0] m; // 8 biti, MSB este bitul 7, LSB bitul 0
+wire[0:4] n;  // 5 biti, MSB este bitul 0, LSB bitul 4
+wire[7:0] a [9:0]; // array multidimensional cu 10 elemente de 8 biti
 </code>
-Această metodă de instanțiere nu este suportată pentru primitive, porturile acestora neavând asociate nume.
-</hidden>
-<note tip>
+===== Exerciții =====
-**Proiectarea Top-Down**
-Proiectarea top-down se referă la partiționarea sistematică și repetată a unui sistem complex în unități funcționale mai simple, a căror proiectare poate fi făcută mai facil. O partiționare și organizare la nivel înalt a unui sistem reprezintă arhitectura acestuia. Unitățile funcționale individuale ce rezultă în urma partiționării sunt mai ușor de proiectat și de testat decât întregul sistem. Strategia divide-et-impera a proiectării top-down ne permite proiectarea de circuite care conțin milioane de porți.
+Pentru implementarea exercițiilor se vor utiliza scheletele de cod din arhiva laboratorului. Scheletele de cod conțin deja un proiect Xilinx ISE și un modul de testare. Urmăriți cerința și zonele marcate cu TODO.
-Instanțierea unui modul în definiția unui alt modul este numită imbricare (eng. //nested module//). Modulele imbricate reprezintă mecanismul oferit de Verilog pentru proiectarea top-down, deoarece imbricarea creează automat o partiționare a sistemului.
+  - **(4p)** Implementați și simulați un **sumator elementar complet**, utilizând sumatoare elementare parțiale.
+    * //Hint//: Urmăriți tutorialul pentru a realiza simularea (săriți peste adăugarea modulului de test, deoarece este deja adăugat).
+    * //Hint//: Consultați [[ac-is:lab:lab00|laboratorul 0]] pentru implementare.
+  - **(3p)** Implementați și simulați un **sumator pe 4 biți**, cu două intrări și două ieșiri. Verificați corectitudinea sumatorului vizualizând semnalele în baza 10.
+    * //Hint//: Consultați [[ac-is:lab:lab00|laboratorul 0]] pentru implementarea unui sumator pe mai mulți biți.
+    * //Hint//: Folosiți sumatorul implementat la exercițiul 1, adăugându-l la proiect din meniul Project→Add Copy of Source… .
+    * //Hint//: Modificați afișarea unui semnal cu click dreapta→Radix→Unsigned Decimal.
+  - **(3p)**  Implementați și simulați un **sumator pe 6 biți**, cu două intrări și o ieșire. Câți biți va avea ieșirea? De ce?
+    * //Hint//: Folosiți atât sumatoare pe 1 bit, cât și sumatoare pe 4 biți.
+  - **(2p)** Implementați și simulați un **comparator** pe un bit. Acesta are două intrări și 3 ieșiri (pentru mai mic, egal și mai mare).
+    * //Hint//: Respectați interfața cerută în scheletul de cod.
-</note>
-=== Sintaxă ===
- * Verilog este un limbaj case-sensitive; ''x_in'' și ''x_In'' sunt tratate ca două semnale diferite.
- * Numele identificatorilor (ex. nume de module, semnale și porturi) pot conține doar //litere//, //cifre//, //_// și //$//; ele trebuie să înceapă cu //_// sau cu o //literă//.
- * Comentariile se marchează cu ''<nowiki>//</nowiki>'' sau se încadrează între ''/*'' și ''*/''.
-== Xilinx ISE ==
-În cadrul laboratorului vom folosi mediul de dezvoltare **Xilinx ISE**, varianta WebPACK, pentru simularea codului Verilog și programarea plăcilor cu FPGA. WebPACK este versiunea gratuită a Xilinx ISE disponibilă pentru download pe site-ul [[http://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/design-tools.html|Xilinx]]. Un [[..:tutoriale:0-ise-install|tutorial]] pentru instalarea versiunii 14.6 (folosite în laborator) găsiți în secțiunea tutoriale. :!: Sistemul de operare Windows 8 nu este suportat în mod oficial.
-Pentru crearea proiectelor și modulelor folosind Xilinx ISE urmăriți [[..:tutoriale:1-ise-proiect|tutorialul]] de pe wiki.
-== Exerciții ==
-  - **(3p)** Simulați sumatorul elementar complet din scheletul de cod. Corectați cele 6 erori de sintaxă din implementare.
-    * Hint: Descărcați scheletul de cod pentru exerciții.
-    * Hint: Scheletul de cod conține deja un proiect Xilinx ISE și un modul de testare.
-    * Hint: Urmăriți [[..:tutoriale:2-ise-simulare|tutorialul]] pentru a realiza simularea (săriți peste adăugarea modulului de test, pașii 2-6, deoarece acesta este deja adăugat). Simularea nu va fi realizată din prima deoarece codul conține erori de sintaxă.
-    * Hint: Comanda de verificare a sintaxei, //Behavioral Check Syntax//, situată deasupra celei de simulare, este utilă pentru detectarea mai rapidă a erorilor. :!: Rulați comanda selectând în prealabil fișierul ''full_adder.v''.
-    * Hint: Erorile de sintaxă găsite vor apărea în fereastra //Errors//.
-    * Hint: Este bine să începeți rezolvarea cu prima eroare, deoarece toate erorile următoare pot fi cauzate de aceasta. Navigați la **începutul** ferestrei de erori și citiți primul mesaj. Apăsând pe link-ul roz veți fi duși la linia de cod care a cauzat eroarea.
-  - **(3p)** Implementați și simulați un multiplexor 4:1. Urmăriți diagrama de semnale generată.
-    * Hint: Consultați [[.:lab00#multiplexorul-41|laboratorul 0]] pentru implementarea unui multiplexor 4:1.
-    * Hint: Respectați interfața cerută în scheletul de cod.
-  - **(2p)** Implementați un sumator pe 4 biți. Verificați corectitudinea sumatorului vizualizând semnalele în baza 10.
-    * Hint: Consultați [[.:lab00#sumatorul-cu-transport-succesiv|laboratorul 0]] pentru implementarea unui sumator pe mai mulți biți.
-    * Hint: Folosiți sumatorul implementat la exercițiul 1, adăugându-l la proiect din meniul //Project->Add Copy of Source...// .
-    * Hint: Modificați afișarea unui semnal cu //click-dreapta->Radix->Unsigned Decimal//.
-  - **(2p)** Implementați și simulați un sumator pe 6 biți. Folosiți un sumator pe 4 biți și două sumatoare pe 1 bit.
-    * Hint: Respectați interfața cerută în scheletul de cod.
-  - **(2p)** Implementați și simulați un comparator pe un bit. Acesta are două intrări și 3 ieșiri (pentru mai mic, egal și mai mare).
-    * Hint: Respectați interfața cerută în scheletul de cod.
-== Resurse ==
+===== Resurse =====
   * {{.:lab01:lab1_skel.zip|Schelet de cod}}
-  * {{.:lab01:sol:lab1_sol.zip|Soluție laborator}} (disponibilă începând cu 05.10.2019)
+  * <html><a class="media mediafile mf_pdf" href="https://ocw.cs.pub.ro/courses/ac-is/lab/lab01?do=export_pdf">PDF laborator</a></html>
-  * <html><a class="media mediafile mf_pdf" href="/ac/wiki/lab/lab01?do=export_pdf">PDF laborator</a></html>
+  * {{.:lab01:sol:lab1_sol.zip|Soluție laborator}}
+<ifauth @ac-is>
-<ifauth @user>
 ----
-  * [[:internal:intro|Ghid asistent]]
+  * {{.:lab01:sol:lab1_sol.zip|Soluție laborator}}
+  * [[ac-is:internal:guidelines|Ghid asistent]]
 </ifauth>
-== Referințe ==
-  * Ciletti, Michael D. "Advanced digital design with the Verilog HDL". Prentice Hall, 2011

Administrativ

Laboratoare (ACS)

Laboratoare (IE)

Teme

Tutoriale

Resurse

ac-is/lab/lab01.1632165571.txt.gz · Last modified: 2021/09/20 22:19 by ionut.pascal

Show page Old revisions

Media Manager Back to top