Slídy z přednášky

Digitální technika
Jazyk VHDL, základy návrhu
Ing. Jakub Št’astný, Ph.D.1
1 [email protected]
FPGA laboratory
Department of Circuit Theory, FEE CTU Prague
Technická 2, Praha 6, 166 27
http://amber.feld.cvut.cz/fpga
Přednášky - DIT
1 První kroky
Proč HDL?
Základní kameny, úrovně abstrakce
Jak se píše obvod?
2 Základní číslicové struktury
Kombinační obvody
Základní aritmetické operace
Sekvenční funkce
3 Nápověda pro příště
Doporučená literatura
http://amber.feld.cvut.cz/fpga
Jazyky HDL – Hardware Description
Language
• dříve – schematické editory, řada nevýhod
• zápis textovým editorem, vyšší produktivita práce,
jednoduché sdílení, univerzální formát
• jednodušší opětovné použití
• přenositelnost–nástroje,techlib
• VHDL, Verilog, SystemVerilog, System-C (běžně
kombinujeme)
• popis na různých úrovních abstrakce
• návrh vs. programování
Jazyky HDL – Hardware Description
Language
Specifikace
Návrh systému
systémový návrh
volba FPGA
Kódování návrhu
(Design Capture)
Co s tím lze dělat
RTL simulace
číslicového simulátoru
Syntéza
netlist
constraints
Rozmı́stěnı́+propojenı́
(Place & Route)
Gate−level simulace
Statická časová
analýza
konfigurace FPGA
Nakonfigurovaný obvod
Validace
• simulovat pomocí
Změna
specifikace
hotové RTL
constraints
• vytvořit vlastní obvod
pomocí nástrojů pro
implementaci
Úrovně abstrakce – úvod
• proces návrhu → neustále se zpřesňující model
• převádíme popis (model) návrhu mezi úrovněmi abstrakce
• čím vyšší úroveň abstrakce, tím potřeba větší rezervy a
méně detailů
• přechod na nižší úroveň abstrakce detaily přidává, zvyšuje
složitost modelu
• modely na vyšší úrovni abstrakce se snáze implementují,
simulace na vyšší úrovni abstrakce běží rychleji, rychlejší
odladění chyb v návrhu.
• abstraktnější model nezachycuje detaily, některé typy chyb
nelze na vyšších úrovních abstrakce ani detekovat
Úrovně abstrakce – úvod
Abstraktni popis
Vetsi "rezervy"
system level
nejrychlejsi implementace
nejrychlejsi odladeni
nejlevnejsi
nejmene presne odhady
RTL level
mnozstvi
detailu
Gate level
Transistor level
Vice detailu
Konkretni popis
Physical level
nejpresnejsi odhady
nejpomalejsi implementace
nejpomalejsi odladeni
nejdrazsi
Úrovně abstrakce – behaviorální
úroveň
• behavioural level
• popis chováním, algoritmus v programovacím jayzce,
programujeme
• př. dělička implementována operátorem dělení
• jeden řádek kódu = i tisíce hradel
• obvykle nepracuje s hodinami, neužívá stavové automaty,
volně nakládá s pamětí.
• lze odladit správnou funkci algoritmů
• obvykle C++, SystemVerilog nebo VHDL
Úrovně abstrakce – behaviorální
úroveň, příklad
Úrovně abstrakce – RTL úroveň
• Register Transfer Level
• sada registrů propojených pomocí kombinačních bloků
• modelujeme mikroarchitekturu navrhovaného systému
• simulace nerespektuje reálná zpoždění na jednotlivých
prvcích logiky, ale velmi rychlá
• př. dělička implementována jako sekvenční obvod
realizující dělení
• jeden řádek kódu = desítky-stovky hradel
• lze odladit implementaci mikroarchitektury systému;
ověříme, zda je kód funkčně správně a obvod reaguje jak
jsme si přáli, nejsme schopni ověřit korektnost interního
časování (zpoždění na kombinačních prvcích, apod.).
• obvykle Verilog, SystemVerilog nebo VHDL
Úrovně abstrakce – RTL úroveň,
příklad
4 bity a
a_in
5 bitu
b
c
d
b_in
c_in
d_in
a_b
c_d
clk
res
6 bitu
e_in
e
Úrovně abstrakce – hradlová úroveň
• back-annotated gate level simulation, timing simulation
• simulujeme finální podobu obvodu implementovaného ve
zvolené technologii
• návrh je popsán ve formě schematu obvodu vyjádřeného
ve zdrojovém kódu (netlist) a před simulací anotován
informacemi o zpoždění na obvodových prvcích a spojích
(back annotation).
• modelujeme reálná zpoždění na prvcích, detailní simulace
• př. dělička implementována jako sekvenční obvod
realizující dělení
• několik řádků kódu = i jen jedno hradlo
• lze odladit detailní časování obvodu
• obvykle Verilog nebo VHDL
Úrovně abstrakce – hradlová úroveň
Úrovně abstrakce – hradlová úroveň –
netlist
Úrovně abstrakce – hradlová úroveň –
anotace zpoždění (SDF)
Úrovně abstrakce – tranzistorová
úroveň
• transistor level
• schéma obvodu sestavené z elementárních obvodových
prvků, tranzistorů (realizovaných příslušnými modely) a
zdrojů
• simulátor pracuje s obvodovými veličinami (proud a
napětí), řeší soustavy diferenciálních rovnic → vyšší
přesnost simulace, ale také významné zpomalení jejího
běhu
• jsou potřeba jiné simulátory, obvykle SPICE a odvozené
• lze odladit např. chyby v rozhraních mezi analogovými a
číslicovými bloky v systému a chování “za číslicovou
abstrakcí"
• obvykle SPICE netlist
Typická podoba návrhu
tb_top
stop_clk
clk_gen
reset_gen
clk
res
výstupy
DUT
vstupy
stimuli_gen
=
DUT
model
OK/FAIL
Jazyky HDL – Hardware Description
Language
Jak si hrát doma
• Xilinx ISE WebPack (syntéza, rozmístění a propojení .... a
simulátor)
• ModelSim PE Student Edition
• vyplňování formulářů – po pravdě :-)
Jazyk VHDL
• VHSIC Hardware Description Language (Very High Speed
Integrated Circuit)
• U.S. Deparment of Defense: jazyk pro dokumentaci
chování integrovaných obvodů – alternativa k tlustým
příručkám :-)
• std. IEEE 1076, první použitelný je IEEE1076-1993
• základ je jazyk ADA, striktní typová kontrola
• později syntéza z RTL – fa. Synopsys
• velmi košatý jazyk demonstrujeme na příkladech
Hello world!
První program
• entita a architektura, 1:N
• jméno souboru=jméno
entity
• architektury:rtl, struct,
behav
• ASSERT-REPORT-
SEVERITY: NOTE,
ERROR, WARNING,
FAILURE
Odmocnina: technika líného muže
• PROCESS – základní blok,
WAIT
• CONSTANT/VARIABLE –
proměnné
• užitečné typy: natural,
integer, boolean, real, time
• FOR LOOP–END
LOOP–EXIT, IF–END IF
• atribut IMAGE
Odmocnina: technika bisekce
• WHILE LOOP – END
LOOP
• FPGA prakticky, kapitola 6
– další techniky, ruční
výpočet a VHDL kód
reálného obvodu :-)
Generování průběhů
• blok s výstupem
• std_logic typ – logický
signál
• WAIT FOR –
nesyntetizovatelné
Sekvenční a paralelní prostředí
Sekvenční a paralelní prostředí
• paralelní prostředí
• BEGIN – END ARCHITECTURE
• paralelně spouštěné činnosti
• hardware je z principu paralelní
• paralelismus je ovšem simulovaný
• sekvenční prostředí
• BEGIN – END PROCESS
• sekvenční běh jako v Javě, C++, atd.
Několik nudných poznámek
• komentáře zapisujeme za – –
• zápisy čísel: 112, 11e5, 2#1010# , 2#1000_0010#,
16#97#, 16#2A#E4
• řetězec – "mrkev", znak – ’c’
Dekodér pro sedmisegm. displej
• první syntetizovatelný kód
• proces s citlivostním
seznamem
• CASE – WHEN
• WHEN OTHERS
Dotazy?
Kombinační
obvody
• změny na vstupu se prošíří na
výstup jen se zpožděním
logických členů
• žádný vnitřní stav obvodu
Invertor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END ENTITY invertor;
ARCHITECTURE rtl OF invertor IS
BEGIN
y<=NOT(x);
END ARCHITECTURE rtl;
Rozhraní bloku
x
y
INVERTOR
Invertor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END ENTITY invertor;
ARCHITECTURE rtl OF invertor IS
BEGIN
y<=NOT(x);
END ARCHITECTURE rtl;
Implementace bloku
x
y
INVERTOR
Architektury: rtl, behav, struct,
gate
Invertor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END ENTITY invertor;
ARCHITECTURE rtl OF invertor IS
BEGIN
y<=NOT(x);
END ARCHITECTURE rtl;
Simulace logických úrovní
• extrémy: dvoustavová
logika vs. analogové
kontinuum
• 9-ti stavová logika –
10XHLUZW• aproximace reálného
analogového světa
• std_logic
• std_logic_vector
Příklad – AND v 9 stavové logice
x
y
z
x/y
0
1
0
1
0
0
0
1
Příklad – AND v 9 stavové logice
x/y
U
X
0
1
Z
W
L
H
–
U
U
U
0
U
U
U
0
U
U
X
U
X
0
X
X
X
0
X
X
0
0
0
0
0
0
0
0
0
0
1
U
X
0
1
X
X
0
1
X
Z
U
X
0
X
X
X
0
X
X
W
U
X
0
X
X
X
0
X
X
L
0
0
0
0
0
0
0
0
0
H
U
X
0
1
X
X
0
1
X
–
U
X
0
X
X
X
0
X
X
std_logic – Rezoluční funkce
Simulace zkratu
• jeden signál buzený z více
míst
• modelování reálného
chování
• funkce v knihovně definuje
výsledek
• praktické pro 3-stavové
sběrnice, atd.
←více procesů–paralelně!
Konfigurace bloků
Znovupoužitelnost
• univerzální bloky (UART, SPI, I2C, CPU, DMA)
• zrychlení návrhu – méně chyb
• v reálném světě je opětovné použití vítané
• standardizace rozhraní
AND – konfigurace bloků
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY and_gate IS
GENERIC (
n : natural := 3
);
PORT (
x : IN std_logic_vector(n 1 DOWNTO 0);
y : OUT std_logic
);
END ENTITY and_gate;
ARCHITECTURE rtl OF and_gate IS
BEGIN
gate_output : PROCESS (x)
VARIABLE cnt : natural;
BEGIN
y <= ’1’;
FOR cnt IN 0 TO n 1 LOOP
IF x(cnt)/=’1’ THEN
y <= ’0’;
END IF;
END LOOP;
END PROCESS gate_output;
END ARCHITECTURE rtl;
Rozhraní bloku
n
x(0)
AND
y
x(1)
x(n−1)
AND – konfigurace bloků
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY and_gate IS
GENERIC (
n : natural := 3
);
PORT (
x : IN std_logic_vector(n 1 DOWNTO 0);
y : OUT std_logic
);
END ENTITY and_gate;
ARCHITECTURE rtl OF and_gate IS
BEGIN
gate_output : PROCESS (x)
VARIABLE cnt : natural;
BEGIN
y <= ’1’;
FOR cnt IN 0 TO n 1 LOOP
IF x(cnt)/=’1’ THEN
y <= ’0’;
END IF;
END LOOP;
END PROCESS gate_output;
END ARCHITECTURE rtl;
Implementace bloku
n
x(0)
AND
y
x(1)
x(n−1)
AND – konfigurace bloků
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY and_gate IS
GENERIC (
n : natural := 3
);
PORT (
x : IN std_logic_vector(n 1 DOWNTO 0);
y : OUT std_logic
);
END ENTITY and_gate;
ARCHITECTURE rtl OF and_gate IS
BEGIN
gate_output : PROCESS (x)
VARIABLE cnt : natural;
BEGIN
y <= ’1’;
FOR cnt IN 0 TO n 1 LOOP
IF x(cnt)/=’1’ THEN
y <= ’0’;
END IF;
END LOOP;
END PROCESS gate_output;
END ARCHITECTURE rtl;
Sekvenční prostředí
1
sekvenční výpočet
2
delta-čas
3
nekonečně rychlé
vykonání
Chování procesu
VHDL kód
1 log: PROCESS (a,b,c)
2 BEGIN
3 d <= a AND b;
4 y <= d OR c;
5 END PROCESS log;
b
a1
a
a2
c
g5
b
andor1d1
zn
y
Chování procesu
VHDL kód
1 log: PROCESS (at ,bt ,ct )
2 BEGIN
3 dt+1 <= at AND bt ;
4 yt+1 <= dt OR ct ;
5 END PROCESS log;
b
a1
a
a2
c
g5
b
andor1d1
zn
y
Chování procesu
VHDL kód
1 log: PROCESS (at ,bt ,ct ,dt )
2 BEGIN
3 dt+1 <= at AND bt ;
4 yt+1 <= dt OR ct ;
5 END PROCESS log;
b
a1
a
a2
c
g5
b
andor1d1
zn
y
Chování procesu
Proměnná vs signál?
log: PROCESS (a,b,c)
VARIABLE d: std_logic;
BEGIN
d := a AND b;
y <= d OR c;
END PROCESS log;
b
a1
a
a2
c
g5
b
andor1d1
zn
y
Událostmi řízená simulace
• event-driven simulation
• rychlá, simulátor počítá jen to, co se mění
• jádro simulátoru je tzv. fronta událostí
• událost = (uzel, čas kdy se má měnit, hodnota na kterou se
má měnit)
Událostmi řízená simulace
zjednodušený simulační algoritmus
1 elaborace návrhu: kompletace hierarchie, expanze
generických konstrukcí, kontrola
2 uzlům v obvodu přiřazeny a dopočteny počáteční stavy,
naplánovány události
3 tc = tn
4 Každý aktivní signál v modelu je aktualizován; každý
proces, který má ve svém citlivostním seznamu signál na
kterém se vyskytla událost, je vykonán. Vzniknou další
události a jsou vloženy do fronty událostí.
5 Čas příštího simulačního cyklu tn se nastaví na nejbližší z
• TIME’HIGH
• kdy je další budič ve frontě událostí je aktivní
• čas ve kterém se probudí nějaký proces v návrhu (uspaný
např. pomocí příkazu WAIT).
6
Pokud tn = tc , pak je další simulační cyklus tzv. delta
cyklus.
Simulátor pokračuje krokem 4.
Implikace pro praxi
• Doba běhu simulátoru roste s velikostí návrhu, s počtem
hodinových cyklů, které synchronní číslicový obvod
zpracovává a s počtem událostí, které jsou modelovány.
• Simulace se zpomaluje směrem k nižším úrovním
abstrakce, kde je třeba modelovat více prvků detailněji.
• Simulace je ukončena, když je fronta událostí prázdná.
Simulaci lze ukončit například pomocí příkazu jazyka
VHDL ASSERT (false) REPORT konec simulace
SEVERITY FAILURE; Snažší je přestat generovat hodiny
pro obvod a přestat stimulovat jeho vstupy.
• Události lze ukládat a zkoumat zpětně (pomocí wave file).
Strukturní popis
Strukturní popis
• jednotlivé bloky
potřebujeme propojit
dohromady
• porty propojit na signály,
nakonfigurovat generické
parametry
• ruční kód – nejvyšší
úroveň bloku
• v procesu návrhu – “netlist”
NOR – instance bloků
LIBRARY IEEE
USE IEEE.std_logic_1164.ALL
;
;
ENTITY nor_gate IS
PORT (
a : IN std_logic;
b : IN std_logic;
y : OUT std_logic
);
Rozhraní bloku
a
COMPONENT invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END COMPONENT invertor;
BEGIN
or_result <= a OR b;
inv_i : invertor
PORT MAP (
x => or_result,
y => y
);
END ARCHITECTURE rtl;
INVERTOR
x
END ENTITY nor_gate;
ARCHITECTURE rtl OF nor_gate IS
SIGNAL or_result : std_logic;
nor_gate
b
or_result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
y
y
NOR – instance bloků
LIBRARY IEEE
USE IEEE.std_logic_1164.ALL
;
;
ENTITY nor_gate IS
PORT (
a : IN std_logic;
b : IN std_logic;
y : OUT std_logic
);
Komponenty
a
COMPONENT invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END COMPONENT invertor;
BEGIN
or_result <= a OR b;
inv_i : invertor
PORT MAP (
x => or_result,
y => y
);
END ARCHITECTURE rtl;
INVERTOR
x
END ENTITY nor_gate;
ARCHITECTURE rtl OF nor_gate IS
SIGNAL or_result : std_logic;
nor_gate
b
or_result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
y
y
NOR – instance bloků
LIBRARY IEEE
USE IEEE.std_logic_1164.ALL
;
;
ENTITY nor_gate IS
PORT (
a : IN std_logic;
b : IN std_logic;
y : OUT std_logic
);
Implementace bloku
a
COMPONENT invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END COMPONENT invertor;
BEGIN
or_result <= a OR b;
inv_i : invertor
PORT MAP (
x => or_result,
y => y
);
END ARCHITECTURE rtl;
INVERTOR
x
END ENTITY nor_gate;
ARCHITECTURE rtl OF nor_gate IS
SIGNAL or_result : std_logic;
nor_gate
b
or_result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
y
y
NOR – instance bloků
LIBRARY IEEE
USE IEEE.std_logic_1164.ALL
;
;
ENTITY nor_gate IS
PORT (
a : IN std_logic;
b : IN std_logic;
y : OUT std_logic
);
Paralelní prostředí
• simulace HW –
paralelismus!
END ENTITY nor_gate;
• event-driven sim.
ARCHITECTURE rtl OF nor_gate IS
SIGNAL or_result : std_logic;
COMPONENT invertor IS
PORT (
x : IN std_logic;
y : OUT std_logic
);
END COMPONENT invertor;
BEGIN
or_result <= a OR b;
inv_i : invertor
PORT MAP (
x => or_result,
y => y
);
END ARCHITECTURE rtl;
a
nor_gate
INVERTOR
x
b
or_result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
y
y
Dotazy?
Návrh sčítačky v hradlech
a
1
2Σ
s
b
a
a
cy b
b
cy_in
s
1
2 Σ cy
a
b
s
s
1
2 Σ cy
cy_out
Syntetizovatelné aritmetické obvody
• HDL jazyky jsou tu kvůli produktivitě
• booleovskou algebru budete v životě potřebovat v řadě
situací, ale ...
• v HDL jazyce se ale pro aritmetické operátory nepoužívá
• př.: sčítačku vyrobíte pomocí operátoru +
• produktivita práce – jeden řádek kódu → řádově desítky
hradel
• syntetizovatelné jsou aritmetické operátory +, -, *
• syntetizovatelné jsou relační operátory operátory <, >, = a
jejich kombinace
• ... a ještě pár dalších co nás ted’ tolik nezajímá
Datové typy a sčítání
Základní kouzlo:
LIBRARY IEEE; USE IEEE.numeric_std.ALL;
SIGNAL a: signed (7 DOWNTO 0);
SIGNAL b: signed (7 DOWNTO 0);
Datové typy
• signed, unsigned
• sběrnice o daném počtu bitů
Násobení
SIGNAL a: signed (7 DOWNTO 0);
SIGNAL b: signed (7 DOWNTO 0);
Násobení
• paralelní násobička
• podle typu vstupů se použije správná struktura
• více v knize FPGA prakticky, kapitola 6
Složitější obvod – minimum a
maximum
komparace_cisel
x>y min_sel
x
0
y
1
min_xy
1
max_xy
0
Dotazy?
Sekvenční
obvody
• výstup obvodu závisí na vstupu a
vnitřním stavu
Jednoduchý registr
res
d
D Q
q
clk
P
Jednoduchý registr s write (clock)
enable
res
0
1
q
clk
ce
D Q
q
Registr se sync. setem a resetem
ares
d
0 10, 11
01
1
00
D Q
bit 1
res
set
bit 0
clk
q
Posuvný registr
• konfigurovatelná šířka
• vnitřní registr o N bitech
• operace skládání vektoru
Čítač
ROM pamět’
Konverzní funkce
• v návrhu vše typu std_logic, std_logic_vector
• aritmetické operátory ale pracují s typy signed a unsigned
• jak to převést?
SIGNAL a: std_logic_vector (7 DOWNTO
SIGNAL b: std_logic_vector (7 DOWNTO
SIGNAL c: std_logic_vector (7 DOWNTO
c <= std_logic_vector (unsigned(a) +
0);
0);
0);
unsigned(b));
Dotazy?
Děkuji za pozornost!
Stavový automat
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
ENTITY automat IS
PORT (
clk : IN std_logic;
res : IN std_logic;
sc : OUT std_logic;
rdy : IN std_logic;
we1 : OUT std_logic;
we2 : OUT std_logic
);
END ENTITY automat;
ARCHITECTURE rtl OF automat IS
TYPE t_state IS (gen_sc, rdy_wait, we1_gen, we2_gen);
SIGNAL current_s : t_state;
SIGNAL next_s
: t_state;
BEGIN
Příklad stavového automatu
• vlastní automat je realizován
pomocí tří procesů
• registr na současný stav
• proces pro generování
příštího stavu
• proces pro generování
výstupů automatu
Stavový automat 2
state_reg : PROCESS (clk, res)
BEGIN
IF res=’1’ THEN
current_s <= gen_sc;
ELSIF clk’EVENT AND clk=’1’ THEN
current_s <= next_s;
END IF;
END PROCESS state_reg;
Stavový automat 3
next state
next_state_gen : PROCESS (current_s, rdy_sc2)
BEGIN
CASE current_s IS
WHEN gen_sc =>
next_s <= rdy_wait;
WHEN rdy_wait =>
IF rdy_sc2=’1’ THEN
next_s <= we1_gen;
ELSE
next_s <= rdy_wait;
END IF;
WHEN we1_gen =>
next_s <= we2_gen;
WHEN we2_gen =>
next_s <= gen_sc;
WHEN OTHERS =>
next_s <= gen_sc;
END CASE;
END PROCESS next_state_gen;
Stavový automat 4
1
output signals
2 outputs : PROCESS (current_s)
3 BEGIN
4
CASE current_s IS
5
WHEN gen_sc =>
6
we1 <= ’0’;
7
we2 <= ’0’;
8
sc <= ’1’;
9
WHEN rdy_wait =>
10
we1 <= ’0’;
11
we2 <= ’0’;
12
sc <= ’0’;
13
WHEN we1_gen =>
14
we1 <= ’1’;
15
we2 <= ’0’;
16
sc <= ’0’;
17
WHEN we2_gen =>
18
we1 <= ’0’;
19
we2 <= ’1’;
20
sc <= ’0’;
21
WHEN OTHERS =>
22
we1 <= ’0’;
23
we2 <= ’0’;
24
sc <= ’0’;
25
END CASE;
26 END PROCESS outputs;
27
28 END ARCHITECTURE rtl;