statnice:bakalar:b0b35lsp

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Logické systémy a procesory ======
==== Realizace operací s daty pomocí kombinačních a sekvenčních logických obvodů s vyloučením hazardů a metastability. Obvodová struktura konečných automatů a řadičů procesorů. Popisy obvodů pomocí HDL jazyků a funkční testová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):

<codedoc code:vhdl> 
[optional_label:] process [(optional sensitivity list)] [is]
[sequential_declarations]
begin
sequential statements
end process [optional_label];
</codedoc>

  * **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 ===

<codedoc code:vhdl> 
-- 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;

</codedoc>


=== 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**

<codedoc code:vhdl> 
[pure | impure ] function function_name (parameter_list) return type_name is
[sequential_declarations]
begin
sequential statements
end [function] [function_name]
</codedoc>

== 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.

<codedoc code:vhdl> 
procedure identifier [ (formal_parameter_list) ] is
[sequential_declarations]
begin
sequential statement(s)
end [procedure] [identifier]
</codedoc>

Zde příklad pro vyhodnocení logického stavu hradla "2-and-or":

<codedoc code:vhdl> 
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;
</codedoc>

======  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 nezávisí na vstupech**, tj. **výstupy** se efektivně generují ze **stavu**, v němž se právě nachází automat. 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. 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


<codedoc code:vhdl> 
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;
</codedoc>


======  Ř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 Q<sub>N–1</sub>, Q<sub>N–2</sub>, … )
  * 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.
  * **Loop 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ě.

=== 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==
  * 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. Ř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==
Princip: Konfigurační buňky jsou vnitřní Flash buňky (nesmí se zaměnit s typy pro SSD). Obsah si pamatují i po vypnutí napájení.

^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==
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ů T CLK, proto se doporučuje přidat i výstupní registr (pipeline) pro zajištění správného časování čtení .

==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. |
Trace: • b0b35apo • b4b35psr
Search

Navigation

Print/export

Tools

QR Code
