CAD Realizacja logiki kombinacyjnej rawski@tele.pw.edu.pl http://rawski.zpt.tele.pw.edu.pl/
Logika kombinacyjna Logika jest logiką kombinacyjna jeśli wartość wyjść w danej chwili zależy wyłącznie od wartości wejść w danej chwili. x1 x2 x3 x4 a g f e a g b c Układ kombinacyjny nie posiada wewnętrznej pamięci ani pętli sprzężenia zwrotnego d W języku VHDL realizowane głównie przy wykorzystaniu instrukcji współbieżnych również procesów Przykładami funkcji kombinacyjnych są: dekodery, multipleksery sumatory 2
Instrukcje współbieżne Współbieżne instrukcje przypisania sygnału (Concurrent Signal Assignment Statements): podstawowe przypisanie do sygnału (simple signal assignment statement) sygnał <= wyrażenie; warunkowe przypisanie do sygnału (conditional signal assignmenet statement) sygnał <= wyrażenie1 when wyrażenie_boolowskie1 else wyrażenie2 when wyrażenie_boolowskie2 else wyrażenie3; selektywne przypisanie do sygnału (selected signal assignment statement) with expression select signal <= wyrażenie1 when stała1, wyrażenie2 when stała2; Zachowanie układu jest niezależne od kolejności instrukcji przyporządkowania sygnałów. Stosowane w specyfikacji typu przepływ danych (dataflow description). 3
Składnia Podstawowe przypisanie do sygnału Boolowskie lub arytmetyczne sygnał <= wyrażenie after time; Propagacja sygnału odpowiadająca czasowi niezbędnemu do obliczenia wyrażenia Z tego względu, że czas propagacji zależy od komponentów, wykorzystanej technologii, sposobu połączeń, procesu wytwarzania i warunków zewnętrznych środowiska, w którym działa urządzenie nie jest możliwa synteza układu o zadanym opóźnieniu jest niemożliwa. Przy opisie VHDL nie specyfikuje się konkretnego opóźnienia i przyjmowane jest domyślne δ-delay 4
Podstawowe przypisanie do sygnału przykłady status <= 1 ; even <= (p1 and p2) or (p3 and p4) aruthm_out <= a + b + 1 5
Przypisanie do sygnału z pętlą sprzężenia zwrotnego library ieee; use ieee.std_logic_1164.all; entity test is port( d, en : in std_logic; q, nq : out std_logic ); end test ; architecture data_flow of test is signal tmp : std_logic; tmp <= (tmp and not en) or (d and en); q <= tmp; nq <= not tmp; end data_flow; To nie jest już układ kombinacyjny na te same pobudzenia wejściowe odpowiada różnie 6
library ieee; use ieee.std_logic_1164.all; Pętlą sprzężenia zwrotnego problemy entity test is port( d, en : in std_logic; q, nq : out std_logic ); end test ; architecture data_flow of test is signal tmp : std_logic; tmp <= (tmp and not en) or (d and en); q <= tmp; nq <= not tmp; end data_flow; Instrukcja przypisania ze sprzężeniem zwrotnym sprawiają, że układ staje się wrażliwy na opóźnienia wewnętrzne i mogą pojawić się oscylacje czy wyścigi krytyczne. Ten styl kodowania nie jest najlepszy i powinien być unikany. 7
Sterowanie wyświetlaczem 7-segmentowym równania Tablica prawdy.i 4.o 7.type fr.ilb x(3) x(2) x(1) x(0).ob a b c d e f g 0000 1111110 0001 0110000 0010 1101101 0011 1111001 0100 0110011 0101 1011011 0110 1011111 0111 1110000 1000 1111111 1001 1111011.e a = (!x(2)&!x(0)) (x(1)&!x(0)) (x(1)&x(0)) (x(2)&!x(1)&x(0)) (x(3)); b = (!x(2)&x(0)) (!x(2)&x(1)) (x(1)&x(0)) (!x(1)&!x(0)); c = (!x(2)&x(0)) (x(2)&!x(0)) (x(1)&x(0)) (!x(1)&!x(0)) (x(2)&!x(1)&x(0)); d = (!x(2)&!x(0)) (x(1)&!x(0)) (!x(2)&x(1)) (x(2)&!x(1)&x(0)) (x(3)); e = (!x(2)&!x(0)) (x(1)&!x(0)); f = (x(2)&!x(0)) (!x(1)&!x(0)) (x(2)&!x(1)&x(0)) (x(3)); g = (!x(2)&x(1)) (x(2)&!x(0)) (x(2)&!x(1)&x(0)) (x(3)); f e a g d b c Espresso.exe -oeqntott seven_segment.pla > seven_segment.eqn 8
Sterowanie wyświetlaczem 7-segmentowym VHDL library ieee; use ieee.std_logic_1164.all; entity seven_seg_controler is port( x : in std_logic_vector (3 downto 0); a, b, c, d, e, f, g : out std_logic ); end seven_seg_controler; architecture data_flow of seven_seg_controler is a <= (not x(2) and not x(0)) or (x(1) and not x(0)) or (x(1) and x(0)) or (x(2) and not x(1) and x(0)) or x(3); b <= (not x(2) and x(0)) or (not x(2) and x(1)) or (x(1) and x(0)) or (not x(1) and not x(0)); c <= (not x(2) and x(0)) or (x(2) and not x(0)) or (x(1) and x(0)) or (not x(1) and not x(0)) or (x(2) and not x(1) and x(0)); d <= (not x(2) and not x(0)) or (x(1) and not x(0)) or (not x(2) and x(1)) or (x(2) and not x(1) and x(0)) or (x(3)); e <= (not x(2) and not x(0)) or (x(1) and not x(0)); f <= (x(2) and not x(0)) or (not x(1) and not x(0)) or (x(2) and not x(1) and x(0)) or (x(3)); g <= (not x(2) and x(1)) or (x(2) and not x(0)) or (x(2) and not x(1) and x(0)) or (x(3)); end data_flow; 9
Sterowanie wyświetlaczem 7-segmentowym wyniki +-------------------------------------------------+ ; Fitter Summary ; +--------------------------+----------------------+ ; Revision Name ; seven_seg_controler ; ; Top-level Entity Name ; seven_seg_controler ; ; Family ; Stratix ; ; Device ; EP1S10F484C5 ; ; Timing Models ; Final ; ; Total logic elements ; 7 / 10,570 ( < 1 % ) ; ; Total pins ; 11 / 336 ( 3 % ) ; ; Total virtual pins ; 0 ; ; Total memory bits ; 0 / 920,448 ( 0 % ) ; ; DSP block 9-bit elements ; 0 / 48 ( 0 % ) ; ; Total PLLs ; 0 / 6 ( 0 % ) ; ; Total DLLs ; 0 / 2 ( 0 % ) ; +--------------------------+----------------------+ 10
Instrukcja selektywnego przypisania with wyrażenie _selekcjonujące select sygnał <= wyrażenie_1 when wybór_1, wyrażenie_2 when wybór_2, wyrażenie_n when wybór_n; Instrukcja selektywnego przypisania przypisuje wyrażenie zgodnie z wartością wyrażenia selekcjonującego. Wynikiem wyliczenia wyrażenia selekcjonującego musi być wartość dyskretna lub tablica 1-D, oznacza to, że liczba możliwych wartości jakie przybierz wyrażenie selekcjonujące jest ograniczona. Wartości wybór_i muszą być różne (żadna wartość nie może się pojawić dwukrotnie) i wszystkie wartości muszą być wymienione, co oznacza, że instrukcja musi dopasować każde z możliwych wartości wyrażenia selekcjonującego do najwyżej jednego wyboru. Pominięcie jakiś wartości spowoduje błąd kompilacji kodu. Error: VHDL Case Statement error at file.vhd(14): Case Statement choices must cover all possible values of expression Słowo kluczowe others może być użyte jako ostatni wybór wybór_n 11
Koncepcja realizacji Realizację instrukcji selektywnego przypisania można przedstawić jako abstrakcyjny układ multipleksujący, który wykorzystując sygnał selekcji przekazuje na wyjście wartość wybranego wyrażenia. with select_expr select sig <= expr_a when c0, expr_b when c1, expr_c when others; Przyjmijmy, że wyrażenie select_expr może przyjąć następujące wartości: c0, c1, c2, c3, c4. Realizacja instrukcji będzie następująca: c4 c3 c2 c1 sig c0 12
Implementacja tablicy prawdy Tablica prawdy wykorzystywana jest do opisu układów kombinacyjnych. Jest szczególnie przydatna do opisu małych układów, realizujących nieregularną logikę. Z tego względu, że tablica prawdy specyfikuje odpowiedzi układu na wszystkie możliwe wartości sygnału wejściowego naturalnym sposobem reprezentacji staje się instrukcji selektywnego przypisania. Można wykorzystać wartość do oznaczenia stanu don t care na wyjściu. Z tego względu, że wartość nie istnieje w realizacji fizycznej niektóre systemy mogą zgłosić błąd, ale mogą także wykorzystać tą informacje w procesie optymalizacji. Wykorzystanie nieokreśloności w układzie a b c o 0 0 1 01 0 1 0 10 1 0 0 11 0 0 0 00 architecture data_flow of test is signal i : std_logic_vector(2 downto 0); i <= a & b & c; with i select o <= "01" when "001", "10" when "010", "11" when "100", "00" when "000", "--" when others; end data_flow; 13
Sterowanie wyświetlaczem 7-segmentowym tablica Tablica prawdy.i 4.o 7.type fr.ilb x(3) x(2) x(1) x(0).ob a b c d e f g 0000 1111110 0001 0110000 0010 1101101 0011 1111001 0100 0110011 0101 1011011 0110 1011111 0111 1110000 1000 1111111 1001 1111011.e library ieee; use ieee.std_logic_1164.all; entity seven_seg_controler is port( x : in std_logic_vector (3 downto 0); a, b, c, d, e, f, g : out std_logic ); end seven_seg_controler; architecture data_flow of seven_seg_controler is signal o : std_logic_vector (6 downto 0); with x select o <= "1111110" when "0000", "0110000" when "0001", "1101101" when "0010", "1111001" when "0011", "0110011" when "0100", "1011011" when "0101", "1011111" when "0110", "1110000" when "0111", "1111111" when "1000", "1111011" when "1001", -------" when others; (a, b, c, d, e, f, g) <= o; end data_flow; f e a g d b c 14
Sterowanie wyświetlaczem 7-segmentowym wyniki +-------------------------------------------------+ ; Fitter Summary ; +--------------------------+----------------------+ ; Revision Name ; seven_seg_controler ; ; Top-level Entity Name ; seven_seg_controler ; ; Family ; Stratix ; ; Device ; EP1S10F484C5 ; ; Timing Models ; Final ; ; Total logic elements ; 7 / 10,570 ( < 1 % ) ; ; Total pins ; 11 / 336 ( 3 % ) ; ; Total virtual pins ; 0 ; ; Total memory bits ; 0 / 920,448 ( 0 % ) ; ; DSP block 9-bit elements ; 0 / 48 ( 0 % ) ; ; Total PLLs ; 0 / 6 ( 0 % ) ; ; Total DLLs ; 0 / 2 ( 0 % ) ; +--------------------------+----------------------+ Wykorzystanie nieokreśloności w układzie 15
4 porty wyjściowe wartość sel[1..0] decyduje o tym, na którym wyjściu pojawi się 1 sel[1..0] out3 out2 Dekoder library ieee; use ieee.std_logic_1164.all; entity decoder is port( sel : in std_logic_vector (1 downto 0); out0, out1, out2, out3 : out std_logic ); end decoder; architecture data_flow of decoder is signal o : std_logic_vector (3 downto 0); out1 with sel select out0 o <= "0001" when "00", "0010" when "01", "0100" when "10", "1000" when "11", "----" when others; (out3, out2, out1, out0) <= o; end data_flow; 16
Multiplekser 2 wejściowe szyny 2 bitowe szyna wyjściowa 2 bitowa sygnał select decyduje o tym, która szyna wejściowa jest przekazywana na wyjście Tablica prawdy.i 5.o 2.p 32.ilb sel a(1) a(0) b(1) b(0).ob o(1) o(0) 00000 00 # sel = 0 A = 0 B = 0 00001 00 # sel = 0 A = 0 B = 1 00010 00 # sel = 0 A = 0 B = 2 00011 00 # sel = 0 A = 0 B = 3 10000 00 # sel = 1 A = 0 B = 0 10001 01 # sel = 1 A = 0 B = 1 10010 10 # sel = 1 A = 0 B = 2 11110 10 # sel = 1 A = 3 B = 2 11111 11 # sel = 1 A = 3 B = 3.e a[1..0] b[1..0] out[1..0] select library ieee; use ieee.std_logic_1164.all; entity mux_2x3 is port( a, b : in std_logic_vector (1 downto 0); sel : in std_logic; o : out std_logic_vector (1 downto 0) ); end mux_2x3; architecture data_flow of mux_2x3 is signal i : std_logic_vector (4 downto 0); i <= sel & a & b; with i select o <= "00" when "00000",-- sel=0 "01" when "00100", "10" when "01000", "11" when "01100", "00" when "00001", "01" when "00101", "10" when "01001", "11" when "01101", "00" when "10000",-- sel=1 "01" when "10001", "10" when "10010", "11" when "10011", "--" when others; end data_flow; 17
Multiplekser wyniki +-------------------------------------------------+ ; Fitter Summary ; +--------------------------+----------------------+ ; Revision Name ; max_2x3 ; ; Top-level Entity Name ; max_2x3 ; ; Family ; Stratix ; ; Device ; EP1S10F484C5 ; ; Timing Models ; Final ; ; Total logic elements ; 2 / 10,570 ( < 1 % ) ; ; Total pins ; 7 / 336 ( 3 % ) ; ; Total virtual pins ; 0 ; ; Total memory bits ; 0 / 920,448 ( 0 % ) ; ; DSP block 9-bit elements ; 0 / 48 ( 0 % ) ; ; Total PLLs ; 0 / 6 ( 0 % ) ; ; Total DLLs ; 0 / 2 ( 0 % ) ; +--------------------------+----------------------+ 18
Problemy związanie z opisem układów tablicą prawdy 2 wejściowe szyny 8 bitowe szyna wyjściowa 8 bitowa sygnał select decyduje o tym, która szyna wejściowa jest przekazywana na wyjście Tablica prawdy tego układu ma 17 wejść, co oznacza, że ma 2 17 = 131072 wierszy.type fr.i 17.o 8.p 131072.ilb sel a(6) a(5) a(2) a(1) a(0) b(6) b(0).ob o(6) o(5) o(4) o(3) o(2) o(1) o(0) 00000000000000000 00000000 -- sel = 0 A = 0 B = 0 00000000000000001 00000000 -- sel = 0 A = 0 B = 1 00000000000000010 00000000 -- sel = 0 A = 0 B = 2 00000000000000011 00000000 -- sel = 0 A = 0 B = 3 00000000000000100 00000000 -- sel = 0 A = 0 B = 4 00000000000000101 00000000 -- sel = 0 A = 0 B = 5 00000000000000110 00000000 -- sel = 0 A = 0 B = 6 00000000000000111 00000000 -- sel = 0 A = 0 B = 7 00000000000001100 00000000 -- sel = 0 A = 0 B = 12 00000000000001101 00000000 -- sel = 0 A = 0 B = 13 00000000000001110 00000000 -- sel = 0 A = 0 B = 14 a[7..0] b[7..0] out[7..0] select 11111111111110100 11110100 -- sel = 1 A = 255 B = 244 11111111111110101 11110101 -- sel = 1 A = 255 B = 245 11111111111110110 11110110 -- sel = 1 A = 255 B = 246 11111111111111010 11111010 -- sel = 1 A = 255 B = 250 11111111111111011 11111011 -- sel = 1 A = 255 B = 251 11111111111111100 11111100 -- sel = 1 A = 255 B = 252 11111111111111101 11111101 -- sel = 1 A = 255 B = 253 11111111111111110 11111110 -- sel = 1 A = 255 B = 254 11111111111111111 11111111 -- sel = 1 A = 255 B = 255.e 19
Multiplekser inna wersja Tablica prawdy.i 5.o 2.p 8.ilb sel a(1) a(0) b(1) b(0).ob o(1) o(0) 000-- 00 -- sel = 0 A = 0 B = X 001-- 01 -- sel = 0 A = 1 B = X 010-- 10 -- sel = 0 A = 2 B = X 011-- 11 -- sel = 0 A = 3 B = X 1--00 00 -- sel = 1 A = X B = 0 1--01 01 -- sel = 1 A = X B = 1 1--10 10 -- sel = 1 A = X B = 2 1--11 11 -- sel = 1 A = X B = 3.e Jeśliby zastosować notację kostkową możliwą w formacie espresso tablica byłaby znacznie mniejsza library ieee; use ieee.std_logic_1164.all; entity mux_2x3 is port( a, b : in std_logic_vector (1 downto 0); sel : in std_logic; o : out std_logic_vector (1 downto 0) ); end mux_2x3; architecture data_flow of mux_2x3 is signal i : std_logic_vector (4 downto 0); i <= sel & a & b; with i select o <= "00" when "000--",-- sel=0 "01" when "001--", "10" when "010--", "11" when "011--", "00" when "1--00",-- sel=1 "01" when "1--01", "10" when "1--10", "11" when "1--11", "--" when others; end data_flow; 20
Multiplekser wyniki +-------------------------------------------------+ ; Fitter Summary ; +--------------------------+----------------------+ ; Revision Name ; max_2x3 ; ; Top-level Entity Name ; max_2x3 ; ; Family ; Stratix ; ; Device ; EP1S10F484C5 ; ; Timing Models ; Final ; ; Total logic elements ; 1 / 10,570 ( < 1 % ) ; ; Total pins ; 7 / 336 ( 3 % ) ; ; Total virtual pins ; 0 ; ; Total memory bits ; 0 / 920,448 ( 0 % ) ; ; DSP block 9-bit elements ; 0 / 48 ( 0 % ) ; ; Total PLLs ; 0 / 6 ( 0 % ) ; ; Total DLLs ; 0 / 2 ( 0 % ) ; +--------------------------+----------------------+ Rewelacyjna realizacja tylko jedna komórka! Układ na wyjściu stale ma wartość 0 Synteza logiczna dała w rezultacie wartość stałą na wyjściu. 21
Multiplekser inna wersja with i select o <= "00" when "000--",-- sel=0 "01" when "001--", "10" when "010--", "11" when "011--", "00" when "1--00",-- sel=1 "01" when "1--01", "10" when "1--10", "11" when "1--11", --" when others; Dlaczego ten zapis daje nieprawidłową realizację? Wartość nieokreślona (don t care) nie jest prawidłową wartością w algebrze boolowskiej jest jednak wykorzystywana w procesie projektowym. Wartość don t care może być użyta jako wartość sygnału wyjściowego by tablica prawdy była bardziej czytelna i mniejsza. Użyta jako wartość sygnału wyjściowego oznacza, że dokładna wartość jest nieistotna i w czasie syntezy można użyć wartości, która zoptymalizuje układ. W języku VHDL wykorzystanie don t care jako wartości sygnału wejściowego jest poprawne syntaktycznie, jednakże w fizycznej realizacji układu nigdy ta wartość nie wystąpi na wejściu układu. Narzędzie CAD nie uwzględni wartości stąd też przedstawiony kod jest równoznaczny z with i select o <= --" when others; 22
library ieee; use ieee.std_logic_1164.all; Multiplekser optymalna wersja entity mux_2x3 is port( a, b : in std_logic_vector (1 downto 0); sel : in std_logic; o : out std_logic_vector (1 downto 0) ); end mux_2x3; architecture data_flow of mux_2x3 is with sel select o <= a when '0', b when others; end data_flow; Ten sposób opisu jest bardzo czytelny i pozwala w łatwo tworzyć multipleksery o różnej liczbie portów wejściowych i różnych rozmiarach szyn danych. Wystarczą drobne modyfikacje kodu, aby zrealizować np. multiplekser 2x16! 23
Proste ALU arg1 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; arg1 opcode simplealu opcode result 0 arg1 1 0 0 arg1 + arg2 1 0 1 arg1 arg2 result entity simplealu is port( opcode : in std_logic_vector (2 downto 0); arg1, arg2 : in std_logic_vector (7 downto 0); result : out std_logic_vector (7 downto 0) ); end simplealu; architecture data_flow of simplealu is signal sum, diff : std_logic_vector (7 downto 0); sum <= std_logic_vector(signed(arg1) + signed(arg2)); diff <= std_logic_vector(signed(arg1) - signed(arg2)); 1 1 0 arg1 and arg2 1 1 1 arg1 or arg2 with opcode select result <= arg1 when "000" "001" "010" "011", sum when "100", diff when "101", arg1 and arg2 when "110", arg1 or arg2 when others; end data_flow; 24
Proste ALU +-------------------------------------------------+ ; Fitter Summary ; +--------------------------+----------------------+ ; Revision Name ; simplealu ; ; Top-level Entity Name ; simplealu ; ; Family ; Stratix ; ; Device ; EP1S10F484C5 ; ; Timing Models ; Final ; ; Total logic elements ; 35 / 10,570 ( < 1 % ); ; Total pins ; 27 / 336 ( 8 % ) ; ; Total virtual pins ; 0 ; ; Total memory bits ; 0 / 920,448 ( 0 % ) ; ; DSP block 9-bit elements ; 0 / 48 ( 0 % ) ; ; Total PLLs ; 0 / 6 ( 0 % ) ; ; Total DLLs ; 0 / 2 ( 0 % ) ; +--------------------------+----------------------+ 25
Instrukcja warunkowego przypisania sygnał <= wyrażenie_1 when wyrażenie_bool_1 else wyrażenie_2 when wyrażenie_bool_2 else wyrażenie_n-1 when wyrażenie_bool_n-1 else wyrażenie_n; Wyrażenia wyrażenie_bool_i zwracają wartość true lub false Wyrażenia te są kolejno wyliczane dopóki jedno z nich nie zwróci wartości true, wtedy sygnał otrzymuje wartość wyliczoną z na podstawię odpowiedniego wyrażenia wyrażenie_i Ostatnie wyrażenia wyrażenie_n decyduje o wartości sygnału jeśli żadne z wyrażeń wyrażenie_bool_i nie dało wartości true. Instrukcja ta nadaje się do realizacji układów, w których niektóre sygnały wejściowe mają większy priorytet niż inne. 26
Koncepcja realizacji Realizację instrukcji warunkowego przypisania można przedstawić jako abstrakcyjny układ multipleksujący, który wykorzystując sygnał selekcji przekazuje na wyjście wartość wybranego wyrażenia. sig <= expr_1 when bool_expr_1 else expr_2 when bool_expr_2 else expr_3 ; Realizacja instrukcji będzie następująca: sig bool_expr_2 bool_expr_1 27
Multiplekser 4 wejściowe szyny 8 bitowe szyna wyjściowa 2 bitowa sygnał select decyduje o tym, która szyna wejściowa jest przekazywana na wyjście a[7..0] b[7..0] c[7..0] out[7..0] library ieee; use ieee.std_logic_1164.all; entity mux_4x8 is port( a, b, c, d : in std_logic_vector (7 downto 0); sel : in std_logic_vector (1 downto 0); o : out std_logic_vector(7 downto 0) ); end mux_4x8; architecture data_flow of mux_4x8 is o <= a when (sel = "00") else b when (sel = "01") else c when (sel = "10") else d ; end data_flow; d[7..0] select Wykorzystanie nieokreśloności w układzie. W tym przypadku nie ma różnicy pomiędzy kodami VHDL, gdyż sprawdzone zostały wszystkie wartości sygnału sel. Jednakże sygnał ten jest typu std_logic_vector wiec może przyjąć 9 2 wartości, ale tylko dla celów symulacji. o <= a when (sel = "00") else b when (sel = "01") else c when (sel = "10") else d when (sel = "11") else "--------"; end data_flow; 28
Układ posiada wejścia: high żądanie przerwania od urządzenia o najwyższym priorytecie middle żądanie przerwania od urządzenia o niższym priorytecie low żądanie przerwania od urządzenia o najniższym Dekoder priorytetu przerwań Układ posiada wyjścia: IRQ_level numer przerwania do obsługi µp high middle low IRQ_level[1..0] high middle low IRQ_level 1 3 0 1 2 0 0 1 1 0 0 0 0 29
Dekoder priorytetu przerwań wersja błędna library ieee; use ieee.std_logic_1164.all; entity irq_dec is port( high, middle, low : in std_logic; irq_level : out std_logic_vector (1 downto 0) ); end irq_dec; architecture data_flow of irq_dec is signal i : std_logic_vector (2 downto 0); i <= high & middle & low; irq_level <= "11" when (i = "1--") else "10" when (i = "01-") else "01" when (i = "001") else "00"; end data_flow; Co jest powodem błędów? Wartość nie jest prawidłową wartością sygnału wejściowego. Kompilator zinterpretował to następująco: irq_level <= "01" when (i = "001") else "00"; 30
Dekoder priorytetu przerwań library ieee; use ieee.std_logic_1164.all; entity irq_dec is port( high, middle, low : in std_logic; irq_level : out std_logic_vector (1 downto 0) ); end irq_dec; architecture data_flow of irq_dec is irq_level <= "11 when (high = '1') else "10" when (middle = '1') else "01" when (low = '1') else "00"; end data_flow; Teraz wszystko jest dobrze! Czy nie można zastosować wartość i czerpać korzyści jakie to daje? 31
library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; Dekoder priorytetu przerwań - inaczej entity irq_dec is port( high, middle, low : in std_logic; irq_level : out std_logic_vector (1 downto 0) ); end irq_dec; architecture data_flow of irq_dec is signal i : std_logic_vector (2 downto 0); i <= high & middle & low; irq_level <= "11" when (std_match(i,"1--")) else "10" when (std_match(i,"01-")) else "01" when (i = "001") else "00"; end data_flow; Teraz też wszystko jest dobrze! Wykorzystanie funkcji std_match z biblioteki numeric_std pozwala na wykorzystywanie zapisu kostkowego z zastosowaniem wartości 32
Warunkowe przypisanie vs. selektywne przypisanie Z punktu widzenia syntezy układu instrukcje te realizują różne struktury komutacyjne. Instrukcja selektywnego przypisania: każdy wybór może być utożsamiany z wierszem tablicy prawdy, stąd też doskonale się nadaje do reprezentacji układów opisanych w sposób podobny do tablicy prawdy, jest mniej efektywna w przypadku, gdy niektóre wartości wejściowe mają większy priorytet niż inne. Instrukcja warunkowego przypisania: wymusza ustaloną kolejność sprawdzania warunków wyboru, nadaje się do opisu układów w których, niektóre wartości wejściowe mają większy priorytet niż inne Można dowolnie konwertować jedną instrukcję w drugą. with sel select sig <= expr_0 when w0, expr_1 when w1 w2, expr_2 when w3 w4 w5, expr_3 when others; sig <= expr_0 when (cond_expr_0) else expr_1 when (cond_expr_1) else expr_2; sig <= expr_0 when (sel=w0) else expr_1 when (sel=w1) or (sel=w2) else expr_2 when (sel=w3) or (sel=w4) or (sel=w5) else expr_3; sel(1) <= 1 when cond_expr_0 else 0 ; sel(0) <= 1 when cond_expr_1 else 0 ; with sel select sig <= expr_0 when 10 11, expr_1 when 01, expr_2 when others; 33
Monitorowanie tamy 7 czujników sygnalizujących stanem wysokim obecność wody 3 bitowe wyjście sygnalizujące poziom wody (0 7) sygnał alarmu gdy poziom wody zbyt niski lub zbyt wysoki sygnał awarii czujników sterownie śluzami zmniejszającymi i zwiększającymi poziom wody czujniki c[6..0] Jak zbudować taki układ!? c[6..0] level[2..0] error alarm p[1..0] 34
Monitorowanie tamy realizacja (1) Biblioteka numeric_std pozwoli skorzystać z operatorów relacyjnych dla typów std_logic_vector Nazwa error jest słowem kluczowym i niektóre kompilatory zgłoszą błąd Pomocniczy sygnał internal_value ułatwi opis działania układu i reprezentuje na bitach 2..0 wartość poziomu wody; najstarszy bit wykorzystany jest do wskazania czy odczyt poziomu wody jest poprawny czy nie. library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity tama is port( c : in std_logic_vector(6 downto 0); error : out std_logic; alarm : out std_logic; level : out std_logic_vector(2 downto 0); p : out std_logic_vector(1 downto 0) ); end tama; architecture data_flow of tama is signal internal_value : std_logic_vector (3 downto 0); alias water_level : std_logic_vector (2 downto 0) is internal_value (2 downto 0) ; alias wrong_level : std_logic is internal_value (3) ; Aliasy water_level i wrong_level ułatwią dostęp do informacji reprezentowanej przez sygnał internal_value 35
Monitorowanie tamy realizacja (2) Instrukcja selektywnego przypisania opisuje reakcje na prawidłowe wskazania czujników, wszystkie inne oznaczają awarię czujników co obsługiwane jest w sekcji others. Sygnał internal_value reprezentuje na bitach 2..0 wartość poziomu wody; najstarszy bit wykorzystany jest do wskazania czy odczyt poziomu wody jest poprawny czy nie. Aliasy water_level i wrong_level ułatwią opis pozostałych sygnałów wyjściowych. with c select internal_value <= "0000" when "0000000", "0001" when "0000001", "0010" when "0000011", "0011" when "0000111", "0100" when "0001111", "0101" when "0011111", "0110" when "0111111", "0111" when "1111111", "1---" when others; alarm <= '1' when ((unsigned(water_level) > 5) or (unsigned(water_level) < 2)) and (wrong_level /= '1') else '0'; p(1) <= '1' when (unsigned(water_level) > 5) and (wrong_level /= '1') else '0'; p(0) <= '1' when (unsigned(water_level) < 2) and (wrong_level /= '1') else '0'; level <= water_level; error <= wrong_level; end data_flow; 36
Monitorowanie tamy wyniki Na wyjściu pojawiają się zaburzenia charakterystyczne dla układów kombinacyjnych wynikające z różnych opóźnień ścieżek sygnałów z wejść układu do jego wyjść. W niektórych sytuacją mogą spowodować nieprawidłowe działanie systemu. 37
Opis z wykorzystaniem instrukcji sekwencyjnych Proces (process) jest konstrukcją VHDL zawierającą zbiór akcji wykonywanych sekwencyjnie, znanych jaki instrukcje sekwencyjne. Proces sam w sobie jest instrukcją współbieżną. Może być interpretowany jako fragment układu zamknięty w czarnej skrzynce, którego zachowanie można scharakteryzować instrukcjami sekwencyjnymi. Nie zawsze istnieje możliwość realizacji fizycznego układu działającego zgodnie z opisanym zachowaniem. Wykonanie operacji wewnątrz procesu jest sekwencyjne, dlatego też kolejność instrukcji ma znaczenie. Wiele instrukcji sekwencyjnych nie ma bezpośredniej reprezentacji w sprzęcie i są trudne lub niemożliwe do realizacji. 38
Proces z listą czułości Składnia procesu z listą czułości jest następująca: process_label: process (signal1, signal2, signal3) -- deklaracje variable variable1 : std_logic; -- instrukcje sekwencyjne end process process_label; Lista czułości reprezentuje sygnały, na które reaguje proces. Proces można interpretować jako fragment układu, który może być aktywny (activated) lub nieaktywny (suspended). Proces jest aktywowany, gdy sygnał występujący na liście czułości się zmieni, podobnie jak układ odpowiadający na zmianę sygnału wejściowego. Gdy proces zostanie aktywowany sekwencyjnie wykonywane są instrukcje aż do końca procesu. Następnie proces jest zawieszany do kolejnej zmiany sygnałów. 39
Niekompletna lista czułości Jednym z problemów często spotykanych przy konstrukcji procesów jest niekompletna lista czułości, czyli taka, w której brakuje jednego lub więcej sygnałów wykorzystywanych w procesie. signal a, b, c, y : std_logic; process (a) y <= a and b and c; end process; Gdy sygnał a się zmieni proces jest aktywowany i układ zachowuje się zgodnie z oczekiwaniem. Jednakże, gdy zmieniają się sygnały b lub c proces pozostaje zawieszony i sygnał y ma ciągle wartość poprzednią. Oznacza to, że układ posiada pewnego rodzaju pamięć wyzwalaną zarówno zboczem narastającym jak i opadającym sygnału a. Dla układów kombinacyjnych wartość wyjść zależy od wejść układu, stąd też wszystkie sygnały wejściowe muszą być umieszczone w liście czułości. 40
Niekompletna lista czułości - przykład Multiplekser 2 portowy, 1 bitowy: a, b porty wejściowe sel sygnał wyboru Niepełna lista czułości proces aktywuje się jedynie przy zmianach sygnału a. Zmiany na wejściach b i sel nie wpływają na działanie układu Warning (10492): VHDL Process Statement warning at test.vhd(15): signal "sel" is read inside the Process Statement but isn't in the Process Statement's sensitivity list library ieee; use ieee.std_logic_1164.all; entity test is port( a, b, sel : in std_logic; o : out std_logic ); end test; architecture behavior of test is process (a) o <= (a and not sel) or (b and sel); end process; end behavior ; Ta symulacja jest prawidłowa! Czyżby inny kod VHDL? System CAD dokonał inteligentnej kompilacji! Działa jak multiplekser, ale tylko wtedy, gdy zmienia się sygnał a 41
Sekwencyjne przypisanie wartości sygnału Sekwencyjne przypisanie sygnału jest identyczne do współbieżnego przypisania: sygnał <= wyrażenie W procesie nie można natomiast używać współbieżnej instrukcji przypisania warunkowego i selektywnego. Inaczej niż w współbieżnym przypisaniu wartości do sygnału, w przypadku przypisania sekwencyjnego wartość sygnałowi jest nadawana po zakończeniu procesu. Wewnątrz procesu sygnałowi może być przypisywana wartość wielokrotnie. Tylko ostatnie przypisanie decyduje o wartości sygnału. process (a, b, c, d) y <= a or b; y <= b xor c; y <= a and d; end process; process (a, b, c, d) y <= a and d; end process; Procesy przedstawione obok dadzą tą samą realizację. Z wyjątkiem szczególnych sytuacji należy unikać wielokrotnych przypisań do sygnału. 42
Sekwencyjne przypisanie wartości zmiennej Sekwencyjne przypisanie wartości zmiennej dokonywane jest natychmiast (nie występuje opóźnienie): zmienna := wyrażenie Zachowanie zmiennych w procesie jest identyczne do tego znanego z języków programowania. Ziemne są lokalne dla procesu i muszą być deklarowane wewnątrz procesu. Pomimo, że zachowanie zmiennej jest łatwe do zrozumienia, odwzorowanie jej w sprzęcie może być trudne. Procesy przedstawione obok dadzą tą samą realizację. process (a, b) variable tmp : std_logic; tmp := 1 ; tmp := tmp and a; tmp := tmp or b; y <= tmp; end process; process (a, b) variable tmp0 : std_logic; variable tmp1 : std_logic; variable tmp2 : std_logic; tmp0 := 1 ; tmp1 := tmp0 and a; tmp2 := tmp1 or b; y <= tmp2; end process; y <= (( 1 and a) or b); 43
Instrukcja warunkowa if Konstrukcja if posiada jedną gałąź then, jedną lub więcej opcjonalnych gałęzi elsif i jedna opcjonalną gałąź else. Wyrażenia expression_i jest wyrażeniem boolowskim zwracającym wartość true lub false. Wyrażenie te są sprawdzane kolejno. Gdy wyrażenie ma wartość true wykonywane są instrukcje w danej gałęzi zaś pozostałe będą pominięte. Jeśli żadne z wyrażeń expression_i nie wylicza się do wartości true i gałąź else istnieje wykonywane są instrukcje w tej gałęzi. Gałęzie konstrukcji if mogą zawierać inne instrukcje sekwencyjne, w tym inne instrukcje if. Odpowiednie i ostrożne stosowanie konstrukcji if może sprawić, że kod będzie czytelniejszy i czasami bardziej efektywny. if expression_1 then statement_1; statement_2; elsif expression_2 then statement_3; statement_4; else statement_5; statement_6; end if; if expression then if expression then statement; elsif expression then statement; else statement; end if; elsif expression then statement; else statement; end if; 44
Porównanie z instrukcją przypisania warunkowego process (a, b, c) if (a > b) then if (a > c) then max <= a; else max <= c; end if; else if (b > c) then max <= b; else max <= c; end if; end if; Konstrukcja if jest podobna do instrukcji przypisania warunkowego. Jednakże jest ona bardziej ogólna, gdyż gałęzie mogą zawierać sekwencje innych instrukcji sekwencyjnych. signal ac_max, bc_max : std_logic; ac_max <= a when (a > c) else c; bc_max <= b when (b > c) else c; max <= ac_max when (a > b) else ac_max; albo max <= a when ((a >b) and (a > c)) else b when (b > c) else c; process (a, b) if (a > b) then y <= a + b; z <= a - b; x <= 1 ; else y <= a - b; z <= a + b; x <= 0 ; end if; Konstrukcja if jest bardziej odpowiednia także w sytuacji, gdy wiele operacji jest kontrolowanych przez to samo wyrażenie boolowskie. y <= a + b when (a >b) else b a; z <= a - b when (a >b) else b + a; x <= 1 when (a >b) else 0 ; 45
Niekompletne gałęzie W instrukcji if tylko gałąź then jest wymagana. Co oznacza, że poniższy kod jest poprawny: process (a, b) if (a = b) then eq <= 1 ; end if; end; Gdy sygnał a jest równy b sygnał eq otrzymuje wartość 1. Dla przypadku, gdy a nie jest równe b nie umieszczono gałęzi else. Zgodnie z semantyką języka VHDL oznacza to, że sygnał eq się nie zmienia i podtrzymuje poprzednią wartość. process (a, b) if (a = b) then eq <= 1 ; else eq <= q; end if; end; 46
Niekompletne gałęzie przykład Komparator 2 portowy, 4 bitowy: a, b porty wejściowe g wyjście wskazujące, że a > b l wyjście wskazujące, że a < b Niepełna lista czułości proces aktywuje się jedynie przy zmianach sygnału a. Zmiany na wejściach b i sel nie wpływają na działanie układu Warning (10631): VHDL Process Statement warning at test.vhd(13): inferring latch(es) for signal or variable "l", which holds its previous value in one or more paths through the process library ieee; use ieee.std_logic_1164.all; entity test is port( a, b : in std_logic_vector(4 downto 0); l, g : out std_logic ); end test; architecture behavior of test is process (a, b) if (a < b) then l <= '1'; g <= '0'; elsif (a > b) then l <= '0'; g <= '1'; end if; end process; end behavior ; Dla sytuacji, gdy a = b wyjścia podtrzymują poprzednią wartość. 47
Niekompletne przypisania sygnałów Instrukcja if ma wiele gałęzi. Istnieje możliwość, że wartość przypisywana jest do sygnału, nie we wszystkich gałęziach, tylko w niektórych. O ile jest to poprawne syntaktycznie, niekompletne przypisania do sygnału wprowadzają niezamierzone elementy pamięciowe do układu. Zgodnie z semantyką języka VHDL sygnał zachowuje wartość, jeśli nie następuję do niego przypisanie. Sygnałom należy przypisywać wartości we wszystkich gałęziach konstrukcji if lub przypisać im wartość domyślną na początku procesu. process (a, b) if (a < b) then lt <= '1'; elsif (a > b) then gt <= '1'; else eq <= 1 ; end if; end process; process (a, b) if (a < b) then lt <= '1'; gt <= 0'; eq <= 0 ; elsif (a > b) then lt <= 0'; gt <= 1'; eq <= 0 ; else lt <= 0'; gt <= 0'; eq <= 1 ; end if; end process; W związku, że w procesie tylko ostatnie przypisanie do sygnału daje efekt, przypisanie wartości początkowej sygnałom pozwala na zwięzły i czytelny opis układu process (a, b) lt <= 0'; gt <= 0'; eq <= 0 ; if (a < b) then lt <= '1'; elsif (a > b) then gt <= '1'; else eq <= 1 ; end if; end process; process; 48
Kontrola dostępu do szyny Moduł będący częścią łańcucha obsługującego dostęp do szyny Urządzenie pierwsze w łańcuchu ma najwyższy priorytet Moduł niżej w łańcuchu musi zapytać o pozwolenie dostępu do szyny modułów znajdujących się wyżej Zezwolenie na dostęp do szyny uzyskuje urządzenie o najwyższym priorytecie spośród urządzeń domagających się dostępu Sygnały aktywne stanem niskim request_out_n grant_in_n local_grant_n local_reguest_n request_in_n grant_out_n 49
Kontrola dostępu do szyny realizacja library ieee; use ieee.std_logic_1164.all; entity daisy_chain is port( request_in_n grant_in_n local_request_n request_out_n grant_out_n local_grant_n ); end daisy_chain; : in std_logic; : in std_logic; : in std_logic; : out std_logic; : out std_logic; : out std_logic Sygnały aktywne staniem niskim warto wyróżnić poprzez dodanie przyrostka do nazwy Proces odpowiedzialny za zgłaszanie do modułu o wyższym priorytecie żądania zezwolenia dostępu do szyny Proces odpowiedzialny za zezwolenie dostępu do szyny dla modułu lokalnego lub dla modułów o niższym priorytecie Ustalenie wartości domyślnych dla sygnałów grant_out_n i local_grant_n dzięki czemu nie trzeba ustalać ich wartości w każdej gałęzi instrukcji if architecture behavior of daisy_chain is request_process: process (local_request_n, request_in_n) if ((local_request_n = '0') or (request_in_n = '0')) then request_out_n <= '0'; else request_out_n <= '1'; end if; end process; grant_process: process (grant_in_n, local_request_n, request_in_n) grant_out_n <= '1'; local_grant_n <= '1'; if (grant_in_n = '0') then if (local_request_n = '0') then local_grant_n <= '0'; elsif (request_in_n = '0') then end if; end if; end process; end behavior ; grant_out_n <= '0'; 50
Kontrola dostępu do szyny wyniki Zezwolenie od urządzenia o wyższym priorytecie Zgłoszenie żądania dostępu od urządzenia o niższym priorytecie Zgłoszenie zapytania do urządzenia o wyższym priorytecie Zezwolenie na dostęp dla urządzenia o niższym priorytecie Zgłoszenie żądania dostępu od urządzenia lokalnego Jak działa to urządzenie?. Zezwolenie od urządzenia o wyższym priorytecie Zdjęcie zezwolenie dla urządzenia o niższym priorytecie i zezwolenie dla urządzenia lokalnego 51
Kontrola dostępu do szyny działanie Urządzenie zgłasza chęć dostępu do szyny Zezwolenie na dostęp dla urządzenia Urządzenie o średnim priorytecie zgłasza chęć dostępu do szyny Zezwolenie dostępu udzielone z równoczesnym zdjęciem zezwolenia dla urządzenia o niższym priorytecie, jednak tylko do momentu, gdy urządzenie o wyższym priorytecie chce dostępu do szyny 52
Instrukcja warunkowa case Konstrukcja case wykorzystuje wartość wyrażenia expression do wybory instrukcji, które mają być wykonane. Wartości jakie daję wyrażenie expression muszą być typu dyskretnego albo muszą być w postaci tablicy jednowymiarowej. Wybory choice_i są wartościami (lub zbiorami wartości), do których może się wyliczyć wyrażenie expression. Każdy z wyborów może się pojawić tylko raz i wszystkie możliwe wartości wyrażenia expression muszą być uwzględnione. Słowo kluczowe others może być użyte jako ostatni wybór dla uwzględnienia wszystkich niewymienionych wartości. case expression is when choice_1 => statement_1; statement_2; when choice_2 => statement_3; statement_4; when choice_n => statement_k; statement_k+1; end case; case expression is when choice_1 => statement_1; statement_2; when choice_2 => statement_3; statement_4; when others=> statement_5; statement_6; end case; 53
Demultiplexer port wejściowy 4 bitowy 4 porty wyjściowe wejście selekcjonujące 2 bitowe wartość sel[1..0] decyduje o tym, na którym wyjście przekazana jest wartość z wejścia i[3..0] a[3..0] b[3..0] c[3..0] d[3..0] sel[1..0] library ieee; use ieee.std_logic_1164.all; entity demux_4x4 is port( i : in std_logic_vector (3 downto 0); sel : in std_logic_vector (1 downto 0); a, b, c, d : out std_logic_vector (3 downto 0) ); end demux_4x4; architecture behavior of demux_4x4 is process (i, sel) a <= (others => '0'); b <= (others => '0'); c <= (others => '0'); d <= (others => '0'); case sel is when "00" => a <= i; when "01" => b <= i; when "10" => c <= i; when others => d <= i; end case; end process; end behavior; Wartości początkowe sygnałów wyjściowych. Zapis (others => 0 ) Ustawia na wszystkich bitach 0 54
Proste ALU arg1 arg1 opcode simplealu result architecture behavior of simplealu is signal src0s, src1s : signed (7 downto 0); src0s <= signed (arg1); src1s <= signed (arg2); opcode library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; result 0 arg1 1 0 0 arg1 + arg2 1 0 1 arg1 arg2 1 1 0 arg1 and arg2 1 1 1 arg1 or arg2 entity simplealu is port( opcode : in std_logic_vector (2 downto 0); arg1, arg2 : in std_logic_vector (7 downto 0); result : out std_logic_vector (7 downto 0) ); end simplealu; process (opcode, arg1, arg2, src0s, src1s ) case opcode is when "000" "001" "010" "011" => result <= arg1 ; when 100 => result <= std_logic_vector(src0s + src1s); when 101 => result <= std_logic_vector(src0 s src1s); when 110 => result <= arg1 and arg2; when others => result <= arg0 or arc2; end case; end process; end behavior ; 55
Niekompletne przypisania sygnałów Inaczej niż w przypadku instrukcji if w instrukcji case muszą być uwzględnione wszystkie możliwe wartości wyrażenia selekcjonującego i nie można ominąć żadnej klauzuli when powoduje to błąd kompilacji. Jednak niekompletne przypisanie ciągle może wystąpić wprowadzając niechciany element pamięciowy. Zgodnie z semantyką języka VHDL sygnał zachowuje wartość, jeśli nie następuję do niego przypisanie. Sygnałom należy przypisywać wartość we wszystkich klauzulach when lub wartość domyślną na początku procesu. process (a) case a is when 11 => o(0) <= '1'; when 10 => o(1) <= '1'; when 01 => o(2) <= '1'; when others => o(3) <= '1'; end case; end process; process (a) case a is when 11 => o(0) <= '1'; o(1) <= 0'; o(2) <= 0'; o(3) <= 0'; when 10 => o(0) <= 0'; o(1) <= 1'; o(2) <= 0'; o(3) <= 0'; when 01 => o(0) <= 0'; o(1) <= 0'; o(2) <= 1'; o(3) <= 0'; when others => o(0) <= 0'; o(1) <= 0'; o(2) <= 0'; o(3) <= 1'; end case; end process; W związku, że w procesie tylko ostatnie przypisanie do sygnału daje efekt, przypisanie wartości początkowej sygnałom pozwala na zwięzły i czytelny opis układu process (a) o <= (others => 0 ); case a is when 11 => o(0) <= '1'; when 10 => o(1) <= '1'; when 01 => o(2) <= '1'; when others => o(3) <= '1'; end case; end process; 56
Parametry czasowe układów kombinacyjnych Układ cyfrowy nie może odpowiadać na zmianę sygnałów wejściowych natychmiastowo. Wyjścia są w rzeczywistości funkcją czasu. Najważniejszą charakterystyką układu jest czas propagacji, czyli czas niezbędny aby układ wygenerował prawidłową, stabilną wartość wyjściową, która jest odpowiedzią na zmianę wartości sygnałów wejściowych. Innym zjawiskiem związanym z parametrami czasowymi układu jest hazard, czyli wystąpienie niepożądanych fluktuacji sygnału wyjściowego przed jego ustabilizowaniem 57
Ścieżka krytyczna systemu Topologiczna ścieżka krytyczna ścieżka wyznaczana przez topologie układu. Wykorzystanie topologicznej ścieżki krytycznej do wyznaczania opóźnienia układu może prowadzić do przeszacowania opóźnienia. Spowodowane jest to przez fałszywe ścieżki propagacji sygnału. Fałszywa ścieżka krytyczna ścieżka topologiczna wzdłuż której sygnał nie propaguje. 7 ns 13 ns Fałszywa ścieżka krytyczna 6 ns 3 ns Rzeczywista ścieżka krytyczna 58
Optymalizacja realizacji o(0) <= i(0) or i(1); o(1) <= i(0) or i(1) or i(2); O(2) <= i(0) or i(1) or i(2) or i(3); Optymalizacja pod kątem wykorzystania zasobów Optymalizacja pod kątem szybkości działania 59
Realizacja logiki kombinacyjnej porady Unikaj pętli sprzężenia zwrotnego. Instrukcja warunkowego przypisania i selektywnego przypisania może być traktowana jako swego rodzaju struktura komutacyjna. Instrukcja warunkowego przypisania wprowadza priorytetową strukturę komutacyjną zbyt duża liczba klauzul when może prowadzić do złożonych kaskadowo połączonych struktur Selektywne przypisanie wprowadza strukturę multipleksującą zbyt duża liczba wyborów prowadzi do multiplekserów o dużej liczbie portów wejściowych. Przy wykorzystywaniu procesów do realizacji układów kombinacyjnych: umieść wszystkie sygnały wejściowe w liście czułości, wyspecyfikuj wszystkie gałęzie instrukcji if, przypisanie do sygnału wyjściowego musi się znaleźć w każdej gałęzi instrukcji if i case, dobrym zwyczajem jest przypisanie wszystkim sygnałom wyjściowym wartości domyślnej na początku procesu. 60