====== Logické systémy a procesory ======
==== Realizace operací s daty pomocí kombinačních a sekvenčních logických obvodů s vyloučením hazardů a metastability. Obvodová struktura konečných automatů a řadičů procesorů. Popisy obvodů pomocí HDL jazyků a funkční testování obvodů. ====
[[https://dcenet.fel.cvut.cz/edu/fpga/doc/LogickeObvodyNaFPGA.pdf|Šustovo skripta]][[https://dcenet.fel.cvut.cz/edu/fpga/doc/UvodDoVHDL1_concurrent_V20.pdf|VHDL I.]][[https://dcenet.fel.cvut.cz/edu/fpga/doc/UvodDoVHDL2_sequential_Vbeta0.51.pdf|VHDL II.]][[https://dcenet.fel.cvut.cz/edu/fpga/navody.aspx|Šustovo stránky předmětu]]
[[https://cw.fel.cvut.cz/wiki/_media/courses/b35apo/lectures/apolos_v11.pdf|APOLOS (Šustovo skripta simplified verze)]]
* Logická CMOS hradla a jejich vlastnosti. Typy AND, NAND, OR, NOR a XOR.
* Minimalizace log. funkcí v Karnaughových mapách, teoretické zázemí, logická krychle, grayovy kódy, skupinová minimalizace. Hazardy v kombinačních obvodech.
* Uplatnění De Morganova teorému. Užití Shannonovy expanze a její aplikace ke konstrukci BDD (Binary Decision Diagram), výhody, omezení
* Základní logické obvody: dekodér 1 z N, demultiplexer, multiplexory a jejich kaskády, sčitačka +1 a -1 a úplná sčítačka. Převodníky mezi binárním a zrcadlový grayovým kódem.
* Úrovňové klopné obvody RS (RS-Latch) z hradel NAND a NOR, jejich chování a za jakých podmínek u nich mluvíme o zakázaných stavech.
* Synchronní klopné obvody DFF (Data Flip-Flop) architektury Primary-Replica (zastarale Master-Slave). Jejich vlastnosti a podmínky činnosti. Metastabilita DFF. Vysvětlení příčin, jak a kdy lze odstranit.
* Čítače a typy jejich spojování do ripple-kaskád a se synchronními přenosy.
* Příkaz process ve VHDL, rozdíl mezi chování blocking := a non-blocking příkazů <=. Popis obvodů DFF ve VHDL procesu. VHDL funkce a procedury.
* Konečné automaty typu Moore a Mealy. Jejich definice, popisy pomocí grafu přechodů, tabulky přechodů a stavové tabulky přechodů (jiný název matice přechodů). Minimalizace automatu Moore na Moore a Moore na Mealy. Kdy lze? Návrh automatu a jeho popis ve VHDL.
* Řadiče a mikroprogrové řadiče. Vlastnosti a architektura.
* Posuvné registry a posuvné registry s lineární zpětnou vazbou (LFSR), pouze hlavní principy jejich teoretického zázemí a vlastnosti.
* Násobení frekvencí fázovými závěsy (Phase-Locked Loop)
* Správné ošetření vstupů, plovoucí vstupy, pomalé náběžné hrany, odstranění zákmitů tlačítek (debouncing). Chránění výstupů s indukčních zátěží a výkonovou zátěží. Chování logického signálu na vodiči.
* Používané FPGA technologie a jejich vlastnosti. Struktura SRAM paměti, paměti s jednoportovou a dvou portovou výběrovou logikou.
======Logická CMOS hradla a jejich vlastnosti. Typy AND, NAND, OR, NOR a XOR.======
{{ :statnice:bakalar:cmos-05-30_20-07-17.png?400 |Struktura NMOS PMOS}}
Většina logických hradel dnes používá CMOS (Complementary Metal–Oxide–Semiconductor) transistory.
* CMOS kombinuje NMOS (N-kanálové) a PMOS (P-kanálové) tranzistory, což zajišťuje nízkou statickou spotřebu.
* Alternativně se používají i TTL (bipolární tranzistory), ale v integrovaných obvodech převládají CMOS.
* Polovodič typu N (Si dopovaný pětivalentní příměsí) – nosiči jsou volné elektrony.
* Polovodič typu P (Si dopovaný třívalenční příměsí) – nosiči jsou díry.
* NMOS (substrát P-typu): při kladném napětí na gate > Vth>Vth vzniká kanál z minoritních nosičů (elektronů) ⇒ tranzistor vodí.
* PMOS (substrát N-typu): při záporném napětí na gate < −Vth<−Vth vzniká kanál z děr ⇒ vodivost; kladné napětí „1“ na gate tranzistor uzavírá.
* Elektrody: Source (zdroj nosičů), Drain (sběrač), Gate (řídicí elektroda), Body (substrát, u IC je vnitřně spojen s S).
=== CMOS Invertor ===
{{:statnice:bakalar:screenshot-2023-04-14-at-2.27.30-pm-768x869.png?250|}}
=== CMOS NAND & NOR===
{{:statnice:bakalar:screenshot-2023-04-14-at-4.02.16-pm-768x471.png?250|}}
{{:statnice:bakalar:screenshot-2023-04-14-at-4.25.13-pm-768x494.png?250|}}
=== CMOS AND & OR & XOR===
{{:statnice:bakalar:screenshot-2023-04-14-at-6.53.45-pm-768x593.png?250|}}
{{:statnice:bakalar:screenshot-2023-04-14-at-6.44.01-pm-768x567.png?250|}}
{{:statnice:bakalar:screenshot-2023-04-14-at-7.09.58-pm-927x1024.png?250|}}
====== Minimalizace log. funkcí v Karnaughových mapách, teoretické zázemí, logická krychle, grayovy kódy, skupinová minimalizace. Hazardy v kombinačních obvodech. ======
==== Karnaughovy mapy ====
Karnaughovy mapy jsou metoda pro minimalizaci logických funkcí. Slouží ke zjednodušení a zpřehlednění zápisu v porovnání s pravdivostní tabulkou. Karnaughova mapa pro $n$ proměnných vždy obsahuje $ 2^n$ polí, kde každé pole reprezentuje kombinaci právě vstupních hodnot.
{{ :statnice:bakalar:karnaugh_example.png?400 |}}
=== Logická hyperkrychle ===
Karnaughovu mapu lze chápat jako rozvinutí n-rozměrné hyperkrychle, kde každý vrchol představuje právě jednu kombinaci vstupů a každá hrana změnu jednoho bitu.
Pokrytí rohů, hran i vnitřních bloků v mapě odpovídá hledání souvislých oblastí (=krychlí) v n-dimenzionálním hyper-krychli.
Příklady vizualizace:
* $n=2$: čtverec
* $n=3$: klasická krychle
* $n=4$: 4D hyperkrychle rozvinutá do mapy 4x4
=== Minimalizace logických funkcí v Karnaughových mapách ===
* **SoP (Sum-of-Products)**: disjunktivní forma - hledáme AND-implikanty („krychle“) pokrývající co nejvíc „1“. Každý implikant odpovídá skupině $ 2^k$ sousedních polí (k=0…n) a vyjádří se jako součin proměnných bez změny hodnoty v těchto polích. Primární implikanty (nelze rozšířit) se ORují do výsledku. Příklad (A and B) or (C and D)
* **PoS (Product-of-Sums)**: konjunktivní forma - analogicky pokrýváme „0“ OR-implikanty a spojujeme je AND, dodefinujeme don't-care na 0. Příklad (A or B) and (C or D)
* **Don't-care (X)**: v mapě u výstupů značí nezáleží-na; lze je zahrnout do implikantů (pro SoP jako „1“, pro PoS jako „0“) a dodatečně je přiřadit ke zvýhodnění pokrytí
=== Grayův kód ===
Popisuje řazení Karnaughovy mapy tak, aby se při jednom horizontálním nebo vertikálním pohybu v mapě měnila pouze jedna logická hodnota najednou - usnadňuje tak čtení. Mapy nejsou řazeny klasicky binárně $\{(00), (01), (10), (11) \} $ ale jako $\{(00), (01), (11), (10) \} $
{{ :statnice:bakalar:gray_example.png?400 |Indexace v Karnaughově mapě pomocí Grayova kódu}}
==== Hazardy ====
Hazardy (přechodové děje) v logických obvodech jsou způsobeny **zpožděním logických hradel** (propagation time delay). Vznikají při **existenci více cest** uvnitř logického obvodu (tj. tehdy, když existují cesty, které mají různé propagační zpoždění). Projevují se jako krátké glitch pulsy, buď **statické** (krátké invertování aktuálního ustáleného stavu - z 0 do 1 nebo z 1 do 0), nebo **dynamické** (série přechodových pulsů).
Při návrhu je potřeba s hazardy vždy počítat, protože jednotlivá zpoždění se mění například s teplotou zařízení a na běžných FPGA je tak nelze zcela odstranit změnou booleovského zápisu (nástroje je však mohou do určité míry potlačit).
Statické hazardy lze v synchronních obvodech potlačit tak, že se **výstup vzorkuje až po ustálení logiky** (po uplynutí worst-case propagation delay), zatímco v asynchronních obvodech mohou způsobit chybu logiky. Obecně se dají potlačit **přidáním redundantních členů** do logické funkce. Zároveň platí, že dynamické hazardy lze potlačit potlačením statických hazardů a zjednodušením logické struktury.
====== Uplatnění De Morganova teorému. Užití Shannonovy expanze a její aplikace ke konstrukci BDD (Binary Decision Diagram), výhody, omezení ======
{{:statnice:bakalar:demorgan-05-30_20-50-11.png?400|}}
==== Shannonova expanze ====
* Při více než 4 proměnných - jednu zvolíme za 0 a uděláme KM, tu samou pak zvolíme za 1 a uděláme KM, výsledek pak dáme dohromady
* Příklad: f(a,b,c,d,e) - 5 vstupů, velká mapa,
* Rozdělíme Shannonem tak, že e prohlásíme 0 = f1(a,b,c,d,0) a vyčíslíme mapu.
* druhá část e = 1 - f2(a,b,c,d,1) a vyčíslíme KM
* Výsledek dohromady dáme (not E and f1) or (E and F2)
{{:statnice:bakalar:shannon-05-30_21-09-13.png?400|}}
* Citlivost na výběr proměnné – záleží, podle které proměnné se rozkládáme; nevhodně zvolená proměnná může vést ke složitějším kofaktorům a žádnému zjednodušení, někdy dokonce k růstu komplexity
* Heuristiky nejsou zaručené – i když se snažíme volit proměnnou tak, aby redukovala co nejvíce členů, nemusíme dosáhnout zmenšení výsledné funkce ani u jednoduchých aritmetických bloků (např. násobičky, sčítačky)
* Exponenciální růst pro některé funkce – bez vhodného uspořádání proměnných může velikost BDD i složitost rozkladu exponenciálně stoupat, což omezuje použití u velkých kombinací.
==== Binary Decision Diagrams (BDD) ====
BDD (Binary Decision Diagrams) jsou datové struktury používané pro reprezentaci a manipulaci s booleovskými funkcemi, například při verifikaci hardwaru či model checkingu - obecně míst, kde se opakovaně vyčísluje mnoho logických výrazů. vycházejí ze Shannonovy expanze booleovské funkce. Jsou reprezentovány jako orientované acyklické grafy (DAG), kde každý vnitřní uzel odpovídá testu jedné proměnné a má dvě hrany: větev pro $x_i = 0$ a větev pro $x_i = 1$
{{ :statnice:bakalar:bdd.png?400 |}}
==Výhody BDD==
* Kanonická reprezentace (pro dané uspořádání proměnných je BDD jednoznačné)
* Efektivní operace jako sjednocení, průnik nebo negace funkcí přímo na grafech
* Umožňují rychlou verifikaci a manipulaci s velkými logickými výrazy
==Omezení BDD==
* Citlivost na pořadí proměnných: nevhodné uspořádání může způsobit exponenciální růst velikosti grafu
* Některé funkce (např. multiplikátory, sčítačky) nemají kompaktní BDD bez speciálních heuristik
Ve většině praktických aplikací se nepoužívají obecné BDD, ale hlavně OBDD (ordered BDD) a ROBDD (reduced ordered BDD).
====== Základní logické obvody: dekodér 1 z N, demultiplexer, multiplexory a jejich kaskády, sčitačka +1 a -1 a úplná sčítačka. Převodníky mezi binárním a zrcadlový grayovým kódem ======
=== Dekodér 1 z N ===
Mají $M$ vstupů a $N$ výstupů ($N = 2^M$), převádí binární kód na aktivaci právě jednoho z N výstupů. Používají se v konečných automatech na očíslování stavů.
2 typy:
* **One Hot** - log. 1 pouze pro jedinou hodnotu vstupů, jinak 0
* **One Cold** - log. 0 pouze pro jedinou hodnotu vstupů, jinak 1
{{:statnice:bakalar:1z4-05-31_10-36-04.png?400|Pravdivostní tabulka 1 z 4}}
{{:statnice:bakalar:znackz-05-31_10-37-00.png?400|KM a schema}}
=== Demultiplexor ===
Stejné jako dekodér 1 z N, navíc přidává data na logický výstup (při $x_1$ a $x_0$ určujících výstup ještě záleží zda Datový bit je 1 nebo 0).
{{:statnice:bakalar:demux-05-31_10-47-20.png?400|Schema demultiplexoru}}
=== Multiplexor ===
Multiplexor je opak Demultiplexoru, který lze chápat jako přepínač typu $N:1$. Převádí $N$ datových vstupů na 1 výstup pomocí M adresních bitů $x_0,\dots, x_{m-1}$ . Adresní bity tak určují, který vstup bude přiveden na výstup - $N:1$.
{{:statnice:bakalar:41-05-31_11-02-37.png?400|Multiplexor 4:1}}
{{:statnice:bakalar:kaskada-05-31_11-03-29.png?400|Kaskáda 5x Mux 4:1 = 16:1}}
=== Úplná sčítačka ===
Úplná sčítačka je složená ze **dvou Half Adderů** (HA, HB), má **3 vstupy** ($\mathbf{x, y, C_{in}}$(Carry)).
Postup výpočtu:
* HA spočte x+y (část součtu bez přenosu)
* HB sečte výsledek HA + Cin (přičte přenos)
{{:statnice:bakalar:screenshot_from_2025-05-31_11-45-47.png?600|Úplná sčítačka}}
=== Sčítačka +1 ===
Přičítá +1 do n-bitového čísla. Používá kaskádu full adderů, kam postupně přetéká carry z předchozího kroku (počáteční stav je full adder s $x=x_0$, $y=1$, $C_{in}=0$). Na nejnižším bitu $x_0$ se provede operace $x_0 + 1$.
* Je-li $x_0 = 0$., výsledkem $S_0 = 1$ a carry = 0 → přičítání končí.
* Je-li $x_0 = 1$., výsledkem $S_0 = 0$ a carry = 1 → carry pokračuje do vyššího bitu.
Pokud Carry proteče celou kaskádou přes nejvyšší bit, přeteče celé n-binární číslo (overflow) - z 1111 se stane 0000.
=== Sčítačka -1 ===
Odečítá −1 od n-bitového čísla. Funguje pomocí kaskády full adderů, kde se místo carry používá borrow (výpůjčka), která se šíří od nejnižšího bitu směrem nahoru. Na nejnižším bitu $x_0$ se provede operace $x_0 - 1$.
* Je-li $x_0 = 1$., výsledkem $S_0 = 0$ a borrow = 0 → odečítání končí.
* Je-li $x_0 = 0$., výsledkem $S_0 = 1$ a borrow = 1 → výpůjčka pokračuje do vyššího bitu.
Na každý vyšší bit $x_i (i \ge 1)$ se aplikuje případný borrow z předchozího kroku.Borrow se tedy šíří přes všechny nejnižší nuly, dokud nenarazí na první jedničku. Pokud borrow proteče až za nejvyšší bit, nastává podtečení (underflow) - z 0000 se stane 1111.
====== Úrovňové klopné obvody RS (RS-Latch)======
=== Klopné obvody RS ===
Reset-Set (RS) latch (úrovňový klopný obvod RS) je **nejjednodušší paměťový prvek**. Umí uchovat **1 bit** informace pomocí zpětné vazby dvou hradel. Existují dvě základní varianty - z NAND a NOR hradel.
== Chování ==
Latch má dvě zpětně propojená hradla, na základě uloženého stavu se při nenulovém vstupu určuje stav následující.
|{{ :statnice:bakalar:screenshot_from_2025-05-31_13-19-43.png?400 |Pravdivostní tabulka RS}}|
^Pravdivostní tabulka RS^
== Zakázané stavy ==
Zakázaným stavem je $Q=NQ$, protože po určitou dobu vzniká metastabilita (obvod není stabilní ani v 1 ani v 0) - po uvolnění vstupů závisí výsledek na jejich zpoždění.
|{{ :statnice:bakalar:screenshot_from_2025-05-31_13-16-32.png?400 |Klopení RS}}|
^Klopení RS-Latch (metastabilita na $Q=QN$)^
====== Synchronní klopné obvody DFF (Data Flip-Flop) ======
=== Princip DFF (Primary-Replica) ===
Data Flip-Flop (DFF) je základní **synchronní paměťový obvod**, který je tvořený dvěma D-latch (RS-latch s //enable// signálem) obvody za sebou. Má vstup (D), výstup (Q) a hodiny (CLK - řídí enable vstup D-latchů). Na každé **aktivní hraně hodin** (rising/falling edge) uloží hodnotu **D do Q**.
{{ :statnice:bakalar:screenshot_from_2025-05-31_15-00-08.png?400 |Ukázka DFF a D-Latch}}
Dva D-latche, které tvoří DFF se nazývají **Primary** a **Replica**, jejich enable vstupy jsou řízeny signálem CLK, respektive jeho invertovanou verzí:
* **Primary** D‐latch („Master“) má ENA = $\neg$CLK (invertované hodiny).
* Dokud je CLK = 1, ENA_Primary = 0 -> Primary je v paměťovém režimu a drží si poslední uložené D.
* Když CLK = 0, ENA_Primary = 1 -> Primary je transparentní a přebírá na svůj vstup hodnotu D (ale zatím nic nepropustí ven).
* **Replica** D‐latch („Slave“) má ENA = CLK.
* Dokud je CLK = 1, ENA_Replica = 1 -> Replica je transparentní a na výstup Q pouští signál z Primary (přes jediný inverter, aby se vyrovnala polarita).
* Když CLK = 0, ENA_Replica = 0 -> Replica se „uzavře“ do paměti, a Q drží tu hodnotu, kterou obdržela v okamžiku, kdy CLK právě překročil hranici 1->0.
Díky propojení právě těchto dvou latchů (Primary + Replica) výsledek Q reaguje pouze na konkrétní hranu (například vzestupnou). Během fáze mezi dvěma po sobě jdoucími hranami se Q nemění, i kdyby D dramaticky kolísalo. Proto se říká, že DFF je edge‐triggered.
{{ :statnice:bakalar:screenshot_from_2025-05-31_15-03-53.png?400 |Princip DFF}}
=== Podmínky činnosti ===
Aby Primary D‐latch „správně“ zachytil vstup D bez rizika metastability, musí být D ustálené po dostatečnou dobu před náběžnou hranou CLK (tzv. **setup time**) a nesmí se měnit hned po hraně (tzv. **hold time**).
Pokud tyto časy nejsou dodrženy, nastane u Primary D‐latch (s určitým pravděpodobnostním rizikem) metastabilita. Pokles CLK (sestupná hrana) naopak nevyžaduje žádné striktní setup/hold pro Replica.
=== Metastabilita ===
Stav, kdy se vnitřní invertory se nedokážou jednoznačně rozhodnout na „0“ nebo „1“ a mohou se někdy dlouho chaoticky „kmitat“, než se ustálí. Vzniká, pokud **D mění hodnotu příliš blízko aktivní hrany CLK** (nedodržení setup/hold). Projevuje se jako nestabilní, váhavý stav vnitřních invertorů Primary D‐latch, který se může rozkládat na čisté 0/1 s nedefinovaným zpožděním.
Je možné ji zmírnit:
* **Dodržet setup/hold**: zajistit, že D je stabilní před a po hraně.
* **Synchronizační řetězce**: zvláště při přenosech signálů mezi různými hodinovými doménami dát signál nejdřív do prvního DFF, pak až do druhého – aby se případná metastabilita rozpadla.
**Nelze ji naprosto vyloučit**, jen zredukovat pravděpodobnost na zanedbatelné minimum.
====== Čítače a typy jejich spojování do ripple-kaskád a se synchronními přenosy ======
=== Ripple kaskáda ===
Zapojení několika stejných digitálních bloků za sebou tak, že výstup jednoho je vstupem dalšího a změna se šíří postupně („vlní se“) od prvního stupně dál.
Když je ripple kaskáda se **synchronním přenosem**, znamená to, že jednotlivé stupně jsou **řízené společným clockem** (synchronně),
ale přenos (carry/borrow) mezi nimi se šíří postupně jako v ripple struktuře.
=== Registr ===
Paralelní sada D‐flip‐flopů (DFF), která na náběžnou hranu CLK „uzamkne“ všechny bity současně. Může mít volitelné synchronní „nulování“ (RESET nebo SCLR), případně asynchronní CLEAR „na všech DFF“.
|{{:statnice:bakalar:screenshot_from_2025-05-31_15-33-13.png?400|4bit registr}}|
^4-bit registr^
=== Čítač ===
Vezmeme n‐bitový registr (kde n je počet DFF), na jeho paralelní výstup $Q$ připojíme kaskádově jednobitovou sčítačku +1 (Full Adder chain).
* Sčítačka spočte $Q + 1$.
* Výsledek (n bitů) vedeme zpět na vstupy registru $D$.
* Při každé náběžné hraně CLK se registr „přepíše“ hodnotou (Q_old + 1).
Tím vzniká n‐bitový čítač, který se „odráždí“ v posloupnosti 0,1,2,3,… modulo $2^n$.
|{{:statnice:bakalar:screenshot_from_2025-05-31_15-36-23.png?400|Dekadický čítač od 0 do 9}}|
^4-bit čítač (mohl by čítat od 0 do 15, ale komparátorem je nastaveno Reset při čítání do 9)^
== Spojování do ripple kaskád ==
Čítače se skládají z řetězu jedno‐bitových adderů + DFF. Výhodné pro malé n, mají jednoduchou konstrukci, ale frekvence omezuje délka řetězce.
== Spojování se synchonními přenosy ==
Synchronní čítače (paralelní sčítačka + mux) dovedou dosáhnout vyšší frekvence u větších n, ale vyžadují větší plošnou logiku (adder, komparátor, mux).
* Viz. obrázek 4-bit čítače s počítáním do 9 a automatický reset na 0 (počítání je ripple carry a nulování je synchronní)
====== Příkaz process ve VHDL, rozdíl mezi chování blocking := a non-blocking příkazů ⇐. Popis obvodů DFF ve VHDL procesu. VHDL funkce a procedury ======
=== Syntéza ve VHDL ===
Syntéze je proces, kdy se abstraktní popis chování obvodu (RTL kód) převede na konkrétní hardwarovou strukturu tvořenou logickými hradly, registry a propojkami.
=== Příkaz process ve VHDL ===
Process je základní konstrukce VHDL, která popisuje sekvenční chování obvodu. Uvnitř procesu se příkazy vykonávají sekvenčně v rámci jednoho běhu simulace.
Proces může popisovat:
* Kombinační logiku (bez clocku)
* Sekvenční logiku (s clockem)
Přesná syntaxe příkazu vypadá takto (části v [ ] lze vynechat):
[optional_label:] process [(optional sensitivity list)] [is]
[sequential_declarations]
begin
sequential statements
end process [optional_label];
* **Sensitivity list** (nebo wait on) - určuje, kdy se tělo procesu provede znovu.
* **Deklarace uvnitř** (proměnné, funkce, procedury) - umožňují definovat lokální variables, případně lokální podprogramy; nelze zde deklarovat signal ani component.
Proces se v syntéze mapuje na **kombinační** nebo **sekvenční** (registrovou) logiku podle jeho struktury:
* **Sekvenční** (flip-flop), pokud obsahuje detekci hrany (if rising_edge(CLK) apod.)
* **Kombinační**, pokud neobsahuje clock a sensitivity list pokrývá všechny vstupy
=== Rozdíl mezi := (blocking) a <= (non-blocking) ===
== := (blocking) ==
Přiřazení **proměnné** (sekvenční přiřazení). Pouze uvnitř procesů, procedur nebo funkcí (sequential statements).
Přiřazení var := expr; okamžitě změní hodnotu proměnné v v té samé „iteraci“ procesu, následující řádek kódu už čte tuto novou hodnotu v (tj. v se chová jako běžná proměnná v imperativním jazyce).
== <= (non-blocking) ==
Přiřazení **signálu** (sig <= expr). Není provedeno okamžitě, ale jejím výsledkem je **vložení** „nové hodnoty” do **fronty aktualizací** (delta‐cykly).
* V průběhu jednoho simulovaného času se nejprve vyhodnotí všechny výrazy napravo od <=, potom se současně (ve stejném čase) přiřadí výsledné hodnoty na výstupy signálů.
* Když **uvnitř procesu** (sensitivity list) přiřadíte sig <= expr;, stávající hodnota sig **zůstává na výstupu** až **do skončení procesu**, pak teprve (v nadcházejícím delta‐kroku) se přepne.
* Ve skutečném hardware by to znamenalo, že signál se změní „po krátké, ale nenulové” době – odpovídá to latenci hradla či registru.
=== Popis obvodů DFF ve VHDL procesu ===
-- Importujeme standardní IEEE knihovny pro práci se signály std_logic
library ieee;
use ieee.std_logic_1164.all;
-- Deklarace entity, tedy rozhraní D‐flip‐flopu
entity DataFlipFlop is
port (
Data : in std_logic; -- Vstup D: data, která chceme ovzorkovat
CLOCK : in std_logic; -- Hodinový signál (CLK), na jehož hranu reagujeme
ENABLE : in std_logic; -- Povolení zápisu: když ENABLE='1', povolíme přepsat Q
ACLRN : in std_logic; -- Asynchronní clear (active‐low): když ACLRN='0', Q se ihned vynuluje
SCLEAR : in std_logic; -- Synchronní clear (active‐high): po náběžné hraně CLK, pokud SCLEAR='1', Q se vynuluje
Q : out std_logic -- Výstup Q: zde se objeví poslední uložená hodnota D
);
end entity DataFlipFlop;
-- Architekturální popis: popisujeme vnitřní chování entity
architecture rtl_final of DataFlipFlop is
begin
-- Proces, který definuje chování DFF
-- Sensitivity list: proces "vidí" změny signálů CLOCK i ACLRN
process (CLOCK, ACLRN)
begin
-- 1) Ošetření asynchronního clear (ACLRN = '0' → okamžitě nastav Q na '0')
if ACLRN = '0' then
Q <= '0';
-- Jakmile ACLRN přejde na '0', obvod se okamžitě vynuluje, nezávisle na stavu hodiny
-- 2) Pokud není aktivní asynchronní clear, čekáme na náběžnou hranu CLOCK
elsif rising_edge(CLOCK) then
-- 2a) Synchronní clear (pokud SCLEAR = '1' na hranu CLK, pak Q ≤ '0')
if SCLEAR = '1' then
Q <= '0';
-- Priorita synchronního clear má přednost před povolením ENABLE a před čtením Data
-- 2b) Pokud žádný clear není aktivní, řešíme ENABLE
elsif ENABLE = '1' then
Q <= Data;
-- Jestliže ENABLE = '1', na hranu CLK se do Q zapíše aktuální hodnota na vstupu Data
-- 2c) Když ani synchronní clear, ani ENABLE není aktivní, zachovává se předešlá hodnota Q
-- (nepíšeme žádné další přiřazení; Q zůstane takové, jaké bylo)
end if;
-- 3) Konec detekce hrany: v jiných případech (kdy ACLRN='1' a žádná hrana CLK) se nic neděje
end if;
end process;
end architecture rtl_final;
=== VHDL funkce a procedury ===
== Funkce ==
Funkce („function“) vrací jednu hodnotu na základě vstupních parametrů. Do obvodu se „rozbalí“ (in‐line) do kombinatorní sítě či logiky, pokud je syntetizovatelná. Funkce nesmí mít výstupní parametry a návratová hodnota je jediný způsob komunikace.
Typy funkce:
* **Pure** - nemá žádné vedlejší efekty a pro stejné vstupy vždy vrátí stejnou návratovou hodnotu, nezávisí na žádném vnějším stavu.
* Vhodná pro **syntézu**
* **Impure** (volatile) - nemá referenční transparentnost (její výstup nemusí být určen pouze vstupy) - může číst venkovní signály, sdílené proměnné, používat file I/O.
* Typicky pro **simulaci nebo elaboraci**
[pure | impure ] function function_name (parameter_list) return type_name is
[sequential_declarations]
begin
sequential statements
end [function] [function_name]
== Procedura ==
Procedury („procedure“) slouží pro popis podřízených bloků logiky, které mohou současně ovlivnit několik signálů nebo proměnných. Mohou „vracet“ více hodnot (pomocí out/inout parametrů) - např. signal Y : out ..., variable W : out ...
Volají se pouze uvnitř sequential domény (procesy, jiné procedury, funkce) - variable přiřazení (':=') vyžaduje sekvenční context.
procedure identifier [ (formal_parameter_list) ] is
[sequential_declarations]
begin
sequential statement(s)
end [procedure] [identifier]
Zde příklad pro vyhodnocení logického stavu hradla "2-and-or":
entity and_or is
port(
a : in std_logic;
b : in std_logic;
d : in std_logic;
e : in std_logic;
g : out std_logic);
end and_or;
architecture and_or_a of and_or is
-- declarative part: empty
begin
process_and_or : process(a,b,d,e)
-- declarative part: empty
begin
g <= (a and b) or (d and e);
end process process_and_or;
end and_or_a;
====== Konečné automaty typu Moore a Mealy ======
=== Definice Finite State Machine (FSM) ===
{{:statnice:bakalar:screenshot_from_2025-05-31_19-08-57.png?350|Definice FSM}}
{{:statnice:bakalar:screenshot_from_2025-05-31_19-28-26.png?350|Mealy a Moore ilustrace}}
=== Popis FSM ===
Používají se všude, kde systém závisí na sekvenci událostí v čase, ne jen na aktuálním vstupu.
== Moore ==
**Výstupy** se generují ze **stavu**, v němž se právě nachází automat. Výstup se změní, pokud se změní stav. Má více stavů a stabilní výstup, je pomalejší.
== Mealy ==
**Výstupy** se generují **ze současného stavu a okamžitého vstupu**, tj. **výstupy** se tvoří v době přípravy automatu na **přechod** z jednoho stavu do druhého (výstup reaguje na změnu vstupu okamžitě). Má méně stavů, je rychlejší, ale je citlivější.
=== Matice přechodů ===
Má formát čtvercové matice sousednosti (eng. adjacency matrix) používané k popisu grafů. Zůstává přehledná i při značném počtu stavů. Je-li p počet všech stavů, pak má rozměr $p\times p$
* řádky - výchozí stav $s_1$ až $s_p$
* sloupce - příští stav $s_1$ až $s_p$
Průsečík - podmínky $x$ přechodu ze stavu $s_k$ do $s_j$
|{{: statnice:bakalar:screenshot_from_2025-05-31_19-26-15.png?400 |Matice přechodů}}|
^Matice přechodů ^
== Tabulka přechodů ==
V **řádcích** všechny možné vnitřní stavy ($s_i$), ve **sloupcích** jsou všechny možné vstupy ($x_i$).
Má dvě části:
* příští stav ($\delta $)
* výstupy ($\omega $) - výstup generovaný ve stavu
Průsečík - následný stav $s_k$
|{{:statnice:bakalar:screenshot_from_2025-05-31_19-27-31.png?400|Tabulka přechodů}}|{{:statnice:bakalar:screenshot_from_2025-05-31_19-45-11.png?400|Graf přechodů Start-Stop}}|
^Tabulka přechodů ^ Graf přechodů Start-Stop ^
=== Transformace FSM ===
K jakémukoli Mooreovu automatu existuje ekvivalentní Mealyho automat **se stejným nebo menším počtem stavů**.
Ke každému Mealyho automatu, který má $\mathbf{N}$ stavů a rozpoznává $\mathbf{X}$ možných kombinací vstupů, existuje ekvivalentní Mooreův automat mající $\mathbf{N\cdot X}$ **stavů**.
Převody se provádí pomocí analýzy tabulky přechodů.
== Převod Moore → Mealy ==
Výstup se přesune ze stavů na přechody, každý přechod dostane výstup cílového Moore stavu. Počet stavů se obvykle nemění. Výstup reaguje rychleji (už během přechodu).
== Převod Mealy → Moore ==
Výstupy se přesunou z přechodů do stavů, ty se obvykle rozdělí podle různých výstupů. Počet stavů často naroste. Výstupy jsou stabilnější.
| {{ :statnice:bakalar:mealy_to_moore.jpg?500 }} |
^ Převod Mealy → Moore (kvalita obrázku je šajs, [[https://www.tutorialspoint.com/automata_theory/mealy_to_moore_machine_conversion.htm|originál tady]]) ^
=== FSM ve VHDL ===
* Úloha Start-Stop
architecture rtlFSM of StartStopFSM is
begin
ifsm: process(CLK)
type state_t is (ROFF, RON); -- enumerated types are reserved only for FSMs
variable state: state_t:=ROFF;
begin
iRedge : if rising_edge(CLK) then
iClrn: if CLRN='0' then state:=ROFF; -- always clear
else
case state is
when ROFF => if START='1' and STOP='0'
then state:=RON; end if;
when RON => if STOP='1'
then state:=ROFF; end if;
end case; end if iClrn;
end if iRedge;
if state=RON then RUN<='1'; else RUN<='0'; end if;
end process;
end architecture;
====== Řadiče a mikroprogrové řadiče. Vlastnosti a architektura ======
Řadiče (control unit) jsou část číslicového systému nebo procesoru, která řídí vykonávání operací v datapathu. Jejich nejpravděpodobnější akcí je **přejití do
následujícího stavu po splnění dané podmínky**. **Generují řídicí signály** pro registry, ALU, paměti, sběrnice a další části obvodu.
Jedná v podstatě o **složitější čítač** s tím rozdílem, že **pro přechod** do dalšího stavu (i.e. přičtení čísla), musí být **splněna nějaká podmínka**.
Máme předem určenou posloupnost stavů, do kterých se po splnění podmínky posouváme:
* when S0 => if start then state := S1; end if;
* when S1 => if full then state := S2; end if;
* when S2 => if boiling then state := S3; end if;
* when S3 => if Chef then state := S0; end if;
{{:statnice:bakalar:screenshot_from_2025-05-31_19-57-14.png?400|Grafické zobrazení Řadiče kotle}}
====== Posuvné registry a posuvné registry s lineární zpětnou vazbou (LFSR), pouze hlavní principy jejich teoretického zázemí a vlastnosti ======
=== Posuvné registry ===
Posuvný registr je série zřetězených D‐flip‐flopů (DFF). Výstup jednoho DFF → vstup následujícího. Posun hodnoty v řetězci nastává při každém taktu hodin (první DFF čte data na vstupu (SI) a posílá dál svoje data do kaskády). Výstup posledního DFF řetězce je SO (Serial Out - výstup registru).
{{:statnice:bakalar:screenshot_from_2025-06-01_09-56-06.png?400|SISO}}
== SISO (Serial-In Serial-Out) ==
* V každém taktu vstupní bit posune všechny bity o jednu pozici doprava; poslední bit „vypadne“.
* Lze použít jako jednoduchou zpožďovací linku (delay line): hodnota na SI se objeví na SO až po N taktech, kde N = počet DFF.
== PISO (Parallel-In Serial-Out) ==
*Má řídicí vstup Load.
*Pokud Load = ’1’, do všech DFF simultánně (paralelně) načte N-bitové slovo.
*Pokud Load = ’0’, pak z toho „načteného” slova posouvá bity sériově ven přes SO.
== SIPO (Serial-In Parallel-Out) ==
*Nahrazuje SO N současnými výstupy Q(N–1 downto 0).
*V každém taktu se do nejnižšího bita vloží SI, starší bity se posunou; všechny N bitů lze číst naráz (paralelně).
== PIPO (Parallel-In Parallel-Out) ==
*Pouze „datový registr” (není čistý posuvný registr), vstupy i výstupy vždy řídí společný Load/CLK.
{{:statnice:bakalar:screenshot_from_2025-06-01_09-57-41.png?400|PISO a SIPO}}
=== Posuvné registry s lineární zpětnou vazbou LFSR ===
LFSR (Linear Feedback Shift Register) je posuvný registr se zpětnou vazbou, kde se **nový vstupní bit** generuje jako **XOR vybraných bitů** registru (tzv. ''tap positions'').
==Takt registru==
* SI ≤ XOR( vybrané bitové „tap“ pozice ze stavu QN–1, QN–2, … )
* Všechny bity se posunou doprava (nebo doleva) o jednu pozici.
* Nejvyšší bit se vymění za předchozí nejnižší výstup SO (nebo jedná zerezní zpětnovazební brána).
==Použití LFSR==
* Generování pseudonáhodných čísel.
* Rozptyl (scrambling) a descrambling v komunikacích (zajišťuje rovnoměrné rozprostření spektra bitů).
* CRC (Cyclic Redundancy Check): zkrácená varianta LFSR bez anamnézy stavu (uložen je pouze registr, výstupem jsou paritní bity).
* Dežifrátory (čítače) pro test operačních frekvencí („BIST” – Built-In Self-Test) v hardwaru.
* Fázové generátory a děliče frekvence s vysokou kvalitou (rozložení spektra).
====== Násobení frekvencí fázovými závěsy (Phase-Locked Loop) ======
Phase-Locked Loop (PLL) je uzavřená regulační smyčka, která synchronizuje fázi a frekvenci lokálního oscilátoru s referenčním signálem.
PLL porovnává referenční frekvenci a zpětnovazební signál odvozený z výstupu VCO a průběžně upravuje oscilátor tak, aby byla minimalizována fázová chyba.
Analogie - převody na kole (Fischer GOAT).
==Bloky PLL==
* **Phase/Frequency Detector (PFD)** – porovnává fázi a frekvenci referenčního a zpětnovazebního signálu..
* **Charge Pump (CP)** – generuje řídicí proudové impulsy.
* **Low Pass Filter (LPF)** – integruje proudy → hladké napětí ($V_{tune}$).
* **VCO (Voltage-Controlled Oscillator)** – oscilátor řízený buď napětím ($V_{tune}$), nebo digitálně.
* **Dividers** $N$ (u reference) a $M$ (ve zpětné vazbě).
==Princip činnosti ==
Uzavřená regulační smyčka, která „zamkne“ fázový posun výstupního oscilátoru (VCO) za fází referenčního signálu.
Upravuje frekvenci VCO tak, aby platilo $\frac{f_{VCO}}{M} = \frac{f_{REF}}{N} $.
== Použití PLL==
* Vytváření stabilních vysokofrekvenčních hodin (z nižší frekvence krystalu).
* Dělení nebo násobení hodinové frekvenci přesně zlomkem.
* Recover hodinový signál z přenášených dat (clock recovery).
* Demodulace frekvenční modulace (FM) v analogové oblasti.
{{:statnice:bakalar:screenshot_from_2025-06-01_10-05-11.png?400|Blokové PLL schéma}}
{{:statnice:bakalar:pll-nvs.png?400|Fischerovo PLL schéma}}
====== Správné ošetření vstupů, plovoucí vstupy, pomalé náběžné hrany, odstranění zákmitů tlačítek (debouncing). Chránění výstupů s indukčních zátěží a výkonovou zátěží. Chování logického signálu na vodiči. ======
=== Ochrana vstupů ===
Všechny vstupy FPGA musí mít **definovanou logickou úroveň** (pull-up/pull-down).
Plovoucí vstup (floating input) vede k náhodnému rušení a vyššímu odběru proudu -> nepoužívané vstupy se **nesmí nechávat nezapojené**.
=== Práce s pomalými náběžnými hranami ===
**Pomalé změny signálu** mohou způsobit opakované **překročení logického prahu**, **vznik metastability**, nebo **zvýšený proud** ve vstupních tranzistorech.
Filtrujeme je buď **Schmittovými vstupy** či **bufferujeme**, **synchronizujeme do hodin** pomocí flip-flopů, aby se vyhnuli metastabilitě.
Schmittův vstup - vstup s hysterezí - má dva napěťové prahy, mezi nimi "šedá zóna", kde nedochází ke změně logické hodnoty (tj. $V_{in} < V_{th-} \implies 0, V_{in} > V_{th+} \implies 1$).
=== Debouncing ===
Odskoky tlačítek (zákmity, bouncing) jsou způsobeny mechanickým odrážením kovových kontaktů při sepnutí nebo rozepnutí tlačítka. Čím je tlačítko opotřebenější, dochází k odskokům častěji.
Dají se ošetřit dvěma způsoby:
* **Hardwarově**: RC článek + Schmitt/invertor (τ ≈ 1 ms) potlačí zákmitové pulsy (zahladí křivku).
* **Softwarově**: ve FPGA čítačový filtr nebo FSM se vzorkováním po definované době -> změna je přijata až po dostatečně dlouhé době.
===Chránění výstupů se zátěží ===
FPGA výstupy nejsou určeny pro přímé řízení výkonových nebo indukčních zátěží.
==Indukční zátěže (cívky, motory, relé) ==
Při vypnutí vzniká vysoké indukované napětí, to může poškodit tranzistory nebo FPGA IO.
Řešení: Flyback dioda pro DC cívky; RC snubber nebo TVS dioda pro AC/rychlé spínání.
==Výkonové zátěže (LED pásky, velké proudy)==
Oddělit výstup FPGA dedikovaným driverem (MOSFET, buffer) s ochranným RC, řídit dI/dt (slew-rate), přidat teplotní/přetížení ochrany.
===Fyzické (analogové) chování logického signálu na vodiči===
Při vyšších rychlostech se vodič chová jako přenosová linka.
== Důležité jevy ==
* **Propagation delay** – konečné zpoždění šíření signálu,
* **Inertial delay** – krátké impulsy se nemusí přenést,
* **Transport delay** – ideální čisté zpoždění,
* **Odrazy** (reflections) – vznikají při nepřizpůsobené impedanci
* **Jitter** – časové kolísání hran signálu,
* **Crosstalk** – rušení mezi sousedními vodiči - nutnost impedance‐match a krátké trasy.
== Pravidla návrhu ==
* Řídit fan-out buffery a minimalizovat kapacitní zatížení kvůli zpoždění
* Do hodinových cest nevkládat další hradla - vyhnutí clock skew (rozdíl v čase, kdy signál dorazí do různých částí systému)
====== Používané FPGA technologie a jejich vlastnosti. ======
=== FPGA Technologie ===
== SRAM-based FPGA - Volatile==
* Princip: Konfigurační buňky tvoří klasické **CMOS SRAM** buňky (8–12 tranzistorů na buňku). Po programování (napájecím pulzu) drží hodnotu, dokud je FPGA zapnuté, ale **po vypnutí se vymažou** (volatilní).
* Řešení: externí Flash–EEPROM čip, který po zapnutí automaticky nahraje bitstream do SRAM buněk
^Výhody^Nevýhody^
|Rychlá a neomezeně opakovatelná rekonfigurace.|Citlivost na radiaci (ztráta konfigurace) → pro kosmické aplikace se vyrábějí verze “radiation-hardened” (umožňují vzdálené dožití softwaru).|
|Velké množství LUT/CLB a embedovaných SRAM bloků (např. Cyclone IV: 3981312 bitů ve 432 blocích M9K, vs. Cyclone II: 483840 bitů ve 105 blocích M4K) |Po ztrátě napájení je nutná opětovná konfigurace (boot time).|
|Digitální PLL pro násobení frekvencí, DSP bloky, rychlé carry-chainy aj.| |
|Relativně nízká cena (např. Cyclone II od ~$20, Cyclone IV od ~$65, rok 2022)| |
== Flash-based FPGA - Non-volatile==
Princip: Konfigurační buňky jsou vnitřní **Flash** buňky (NAND nebo NOR). Obsah si pamatují i po vypnutí napájení (nevolatilní).
* NOR flash - přístup k jednotlivým bytům/slovům (tj. random access) - vhodná pro firmware/boot
* NAND flash - přístup k blokům/stránkám - vhodná pro větší objem dat
^Výhody^Nevýhody^
| Konfigurace je zachována i po vypnutí napájení (nevolatile). | Pomalejší rekonfigurace než SRAM FPGA. |
| Rychlý start – FPGA je po zapnutí okamžitě funkční. | Obvykle vyšší cena než čisté SRAM varianty. |
| Nižší klidová spotřeba (není nutná externí konfigurační paměť). | Menší flexibilita při častém přepisu konfigurace. |
| Vyšší odolnost proti částečné radiaci než SRAM FPGA. | Omezený počet přepisovacích cyklů Flash buněk. |
== Antifuse-based FPGA - ROM==
Princip: Konfigurační prvek je **antifuse** prvek (připomíná pojistku, ve výchozím stavu otevřený, programovacím pulzem se neprůstřelně „přepálí” a vytvoří pevný vodivý spoj)
^Výhody^Nevýhody^
| Velmi vysoká odolnost proti radiaci (vhodné pro kosmické aplikace). | Jednorázové naprogramování – nelze přepsat. |
| Velmi stabilní a spolehlivé propojení (fyzický vodivý spoj). | Velmi dlouhá a neflexibilní konfigurace (jednorázový proces). |
| Žádná potřeba konfigurační paměti po zapnutí. | Vyšší riziko chyb při návrhu – nelze opravit po výrobě/programování. |
| Nízká citlivost na SEU (single event upset). | Nevhodné pro vývoj a prototypování. |
====== Struktura SRAM paměti, paměti s jednoportovou a dvou portovou výběrovou logikou. ======
=== Struktura SRAM pamětí v FPGA ===
* Paměťové bloky (M4K / M9K)
* Každý blok je krokovatelný na různé šířky a hloubky:
* Cyclone II: M4K bloky (4 kbit + 512 paritních) → lze použít například jako 4 kb × 1, 2 kb × 2, 512 B × 8, apod. .
* Cyclone IV: M9K bloky (8 kbit + 1024 paritních) → větší kapacita a širší vnitřní sběrnice.
* Uvnitř: statická CMOS SRAM matice, každý bit uložen v buketě CMOS tranzistorů; při změně adresy se data objeví na výstupu s typickým zpožděním ~1–2 cyklů CLK, proto se doporučuje přidat i výstupní registr (pipeline) pro zajištění správného časování čtení.
* Používá DFF
==Jednoportová (Single-Port) SRAM==
Má **jednu adresní sběrnici**, jedno data‐in a jedno data‐out, a jeden řídicí vstup např. „Write Enable (WE)“ + hodinový vstup.
Operace:
* Čtení: Adresa se na chvíli drží konstantní (v registru), po ~1–2 CLK se na datovou sběrnici objeví obsah.
* Zápis: Při aktivním WE se během jednoho cyklu do vybrané buňky zapíše data.
^Výhody^Nevýhody^
| Jednoduchá architektura paměťového bloku. | Nelze současně číst a zapisovat. |
| Menší plocha a nižší spotřeba. | Konflikt mezi čtením a zápisem (pipeline hazard). |
| Snadná implementace v FPGA (LUT/RAM bloky). | Omezená propustnost paměti. |
==Dvouportová (Dual-Port) SRAM==
Obsahuje **dvě nezávislé adresní sběrnice** (adresy A, B), každou se samostatným datovým vstupem, výstupem a hodinou.
Operace:
* Obě strany (porty) mohou libovolně číst či psát současně.
* Pokud se snaží oba porty přistoupit k téže buňce zároveň, je definováno, který **port má prioritu** (typicky „write first“ nebo „read first“).
^Výhody^Nevýhody^
| Možnost současného čtení a zápisu. | Vyšší spotřeba a větší plocha. |
| Paralelní přístup ze dvou nezávislých zdrojů. | Složitější řídicí logika. |
| Vhodná pro FIFO a sdílené buffery mezi doménami. | Riziko konfliktů při přístupu ke stejné adrese. |
==Víceportové (Multi-Port) SRAM==
Některé FPGA umožňují 4portové či 8portové bloky (především uvnitř vestavěných procesorů). Každý port samostatně může číst či zapisovat. Softwarově se konfiguruje, zda bude port jako čtecí či zapisovací.
^Výhody^Nevýhody^
| Velmi vysoká paralelní propustnost paměti. | Výrazně vyšší hardwarová složitost. |
| Možnost více nezávislých čtení/zápisů současně. | Vysoká spotřeba a plocha. |
| Vhodné pro specializované výpočetní jednotky. | Komplexní arbitráž přístupu mezi porty. |