12. cyfrowe przetwarzanie sygnalow(cb)rawski.zpt.tele.pw.edu.pl/pl/system/files/cyfrowe...

Cyfrowe przetwarzanie sygnałów

CAD

Mariusz Rawski

[email protected]

http://rawski.zpt.tele.pw.edu.pl/

Cyfrowe przetwarzanie sygnału

• A/D – konwersja sygnału analogowego na cyfrowy (próbkowanie, kwantyzacja, kodowanie)

• DSP – układy cyfrowego przetwarzania :

– filtracja FIR

– filtracja IIR

( ) ( )∑=

−=M

mmnxmbny

0( ) ( ) ( )∑ −+∑ −=

NM– filtracja IIR

– transformacja Fouriera

– funkcja korelacji wzajemnej

Charakterystyczne jest to, że wszystkie te obliczenia posiadają postać:

Składają się z mnożeń połączonych z akumulacją MAC (Multiply and Accumulate).

• D/A – konwersja sygnału cyfrowego na analogowy

Mariusz Rawski 2

( ) ( ) ( )∑=

−+∑=

−=N

kknyka

M

mmnxmbny

10( ) ( ) nkNj

eN

nnxkX

)/2(1

0

π−∑−

==

( ) ( ) ( )∑=

+=N

nmnynx

NmyxR

0

1,

∑=

+++==N

n NyNxyxyxnynxA1

...2211

Operacja MAC (Multiply and Accumulate)

• Podstawowa operacja w cyfrowym przetwarzaniu sygnałów

• Składa się z operacji mnożenia i dodawania

• Realizowana w procesorach DSP jako jednostka obliczeniowa

RejestrData in

Jednostka MACAlgorytm iteracyjny

Przykład:

Filtr FIR 256 rzędu = 256 operacji mnóż i przechowaj (MAC) na pojedynczą próbkę danych

Mariusz Rawski 3

Data out

MAC MAC

MAC MAC

MAC MAC MAC MAC MAC MAC MAC MAC




Wydajne Procesory DSP

Wysoce zrównoleglone przetwarzanie w FPGA

Procesory DSP vs. FPGA

• Stała nieelastyczna architektura • Można realizować setki przekształceń • Stała nieelastyczna architektura– Typowo 1- 8 jednostki MAC – Stała szerokość danych

• Przetwarzanie szeregowe ogranicza przepustowość

– Współdzielone w czasie jednostki MAC– Duże częstotliwości taktowania stawiają

duże wyzwania projektantom systemów

• Wymagane wiele cykli zegara– Filtr FIR 200 stopniowy wymagać będzie

25+ cykli zegara na próbkę w przypadku procesora z 8 jednostkami MAC

• Można realizować setki przekształceń MAC w jednym układzie FPGA

• Zrównoleglona realizacja umożliwia dużą przepustowość

– Filtr FIR 200 stopniowy wymaga 1 cykl zegara na próbkę

Mariusz Rawski 4

Elastyczność układów FPGA

FPGA – Optymalizacja realizacji

× +

Parallel Semi-Parallel Serial

MAC

×

×

×

+

+

+

+

+

+×

+

+

D Q×

×+

+

+

+

D Q

Szybkość Koszt

Q = (A x B) + (C x D) + (E x F) + (G x H)

Mariusz Rawski 5

Architektura FPGA vs. DSP – wydajność kosztem powierzchni

Źródło: WP116, Xilinx Spartan-II FIR Filter Solution, 2000

Mariusz Rawski 6

Definicja

Filtr cyfrowy FIR

1,...,0 1

0

−==∑−

=− Nncxy

L

kknkn

� Filtracja – proces przetwarzania sygnału w dziedzinie czasu polegający na � Filtracja – proces przetwarzania sygnału w dziedzinie czasu polegający na redukowaniu i usunięciu niepożądanych składowych zawartych w sygnale wejściowym. Filtr cyfrowy to algorytm lub proces obliczeniowy w wyniku którego jedna sekwencja liczb (tzn.sygnał wejściowy) zamieniany jest w inną sekwencję (tzn. sygnał wyjściowy).

� Jest szeroko stosowana w przetwarzaniu sygnałów.� Obliczenie tych sum w sposób bezpośredni wymaga O(L2) operacji

arytmetycznych

Mariusz Rawski 7

Filtr o skończonej odpowiedzi impulsowej FIR

• L – rząd filtru, c[n] – współczynnik, z-1 – element opóźniający

1

0∑

−

=−=

L

kknkn cxy

L-1 sumowań, L mnożeń

Mariusz Rawski 8

Realizacja operacji MAC

X[L-1] ●●● X[1] X[0]

Rejestr przesuwający Ukł. mnożący AkumulatorSumator

∑−

= −−+++==1

0 11...1100

L

n LcLxcxcxncnxy

Mariusz Rawski 9

C[L-1] ●●● C[1] C[0]

××××+ R

Sumatory

• Sumowanie jest najpowszechniejszą operacją arytmetyczną

• Służy jako część składowa innych operacji (np.. mnożenia)

• Służy do realizacji odejmowania poprzez sumowanie argumentu ze zmienionym znakiem

BA

argumentu ze zmienionym znakiem

• Sumator jest logiką kombinacyjną, Można użyć najprostszego sposobu i opisać sumator tablicą prawdy

Mariusz Rawski 10

S

Prosta realizacja sumatora

library ieee;use ieee.std_logic_1164.all;

entity add_tab isport(

a, b : in std_logic_vector(7 downto 0);cout : out std_logic;s : out std_logic_vector(7 downto 0)

);end add_tab;

architecture arch of add_tab issignal tab_in : std_logic_vector(15 downto 0);signal tab_out : std_logic_vector(8 downto 0);

begintab_in <= (a & b);

• Sumator jest logiką kombinacyjną

• Można użyć najprostszego sposobu i opisać sumator tablicą prawdy

• Zadanie: – Zaprojektować sumator dwuargumentowy 4-

bitowy

• Dane:– A[7..0], B[7..0]

• Wynik:– cout, S[7..0]

BA

S

cout

tab_in <= (a & b);s <= tab_out(7 downto 0);cout <= tab_out(8);

PLA: process(tab_in)begin

case tab_in iswhen "0000000000000000" => tab_out <= "000000000";when "0000000000000001" => tab_out <= "000000001";when "0000000000000010" => tab_out <= "000000010";when "0000000000000011" => tab_out <= "000000011";

●●●when "1111111111111110" => tab_out <= "111111101";when "1111111111111111" => tab_out <= "111111110";when others => tab_out <= "XXXXXXXXX";

end case;end process;

end;

Mariusz Rawski 11

SZALETY

• Prosta koncepcja

• Zaprojektowanie takiego sumatora nie wymagazbyt wielkiej wiedzy

Zbyt proste, żeby było …

Prosta realizacja sumatora – wyniki

Fitter Summary

Top-level Entity Name add_tab

Family StratixFamily Stratix

Device EP1S10F484C5

Total logic elements 29 / 10,570 ( < 1 % )

Total pins 25 / 336 ( 7 % )

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 % )

• Prosta koncepcja, ale sposób opisu nie do przyjęcia:– dla sumatora 8-bitowego tablica ma 216 = 65 536 wierszy– dla sumatora 16-bitowego tablica ma 232 = 4 294 967 296 wierszy

Mariusz Rawski 12

Sumator 1-bitowy – full adder

• Równania sumatora

• Równanie boolowskie sumy:

sk = ak xor bk xor ck = ak ⊕ bk ⊕ ck

• Równanie boolowskie przeniesienia:

ck+1 = (ak and bk) or (ak and ck) or (bk and ck) = (ak • yk) + (ak • ck) + (bk • ck) c a b c sk k k k k k

Mariusz Rawski 13

ck ak bk ck+1 sk

0 0 0 0 0

0 0 1 0 1

0 1 0 0 1

0 1 1 1 0

1 0 0 0 1

1 0 1 1 0

1 1 0 1 0

1 1 1 1 1

library ieee;use ieee.std_logic_1164.all;

entity full_adder_1bit isport(

a, b, cin : in std_logic;s, cout : out std_logic

);end;

architecture arch of full_adder_1bit isbegin

s <= a xor b xor cin;cout <= (a and b) or (a and cin) or ( b and cin);

end;

Sumator ripple-carry adder (RCA)

library ieee;use ieee.std_logic_1164.all;use ieee.numeric_std.all;

entity rca isgeneric(

WIDTH : integer := 8);port(

a, b : in std_logic_vector(WIDTH-1 downto 0);cout : out std_logic;s : out std_logic_vector(WIDTH-1 downto 0)

);end;

architecture arch of rca is

beginc(0) <= '0';cout <= c(WIDTH);

rcastages:architecture arch of rca is

component full_adder_1bit isport(

a, b, cin : in std_logic;s, cout : out std_logic

);end component;

signal c : std_logic_vector(WIDTH downto 0);

rcastages:for i in WIDTH-1 downto 0 generate

stagei : full_adder_1bitport map(

a => a(i),b => b(i),cin => c(i),s => s(i),cout => c(i+1)

);end generate;

end;

Mariusz Rawski

Sumator ripple-carry adder – wyniki

Fitter Summary

Top-level Entity Name rca


Device EP1S10F484C5


Total pins 25 / 336 ( 7 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 15

Carry-ripple adder - wady

Jaka jest ścieżka krytyczna tego

układu?

• Liczba komórek:

– O(N) – liniowo zależna od wielkości sumatora

• Opóźnienie:

– O(N) – liniowo zależne od wielkości sumatora

Mariusz Rawski 16

Przyspieszenie sumowania

• Kluczem do przyspieszenia dodawania jest zmniejszenie opóźnienia sieci propagacji sygnału przeniesienia

• Z punktu widzenia propagacji tego sygnału nieistotne są wartości konkretnych operandów

• Znaczenie ma czy w danym stopniu sumatora sygnał przeniesienia jest

– generowany (generate),– propagowany (propagate),

– pochłaniany (anihilate).

Mariusz Rawski 17

Optymalizacja propagacji przeniesienia

• Warunek generacji przeniesienia:

– gi = ai and bi

• Warunek propagacji przeniesienia:

– pi = ai xor bi

c a b c s

• Warunek pochłaniania przeniesienia:

– anii = (not ai) and (not bi)

Mariusz Rawski 18

ck ak bk ck+1 sk

0 0 0 0 0

0 0 1 0 1

0 1 0 0 1

0 1 1 1 0

1 0 0 0 1

1 0 1 1 0

1 1 0 1 0

1 1 1 1 1

Sumator carry lookahead (CLA)

• Przewidywanie przeniesienia

– ci = gi-1 + ci-1pi-1

• Przeniesienia kolejnych stopni sumatora

– c1 = g0 + cinp0

– c2 = g1 + g0p1 + cinp0p1

– c3 = g2 + g1p2 + g0p1p2 + cinp0 p1p2

Mariusz Rawski 19

Sumator carry lookahead (CLA)


begin

pstructure:for i in WIDTH-1 downto 0 generate

• Warunek generacji przeniesienia:

– gi = ai and bi

• Warunek propagacji przeniesienia:

– pi = ai xor bi

• Przewidywanie przeniesienia

– ci = gi-1 + ci-1pi-1

entity cla isgeneric(



);end;architecture arch of cla is

signal c : std_logic_vector(WIDTH-1 downto 0);signal p : std_logic_vector(WIDTH-1 downto 0);signal g : std_logic_vector(WIDTH-1 downto 0);

for i in WIDTH-1 downto 0 generatep(i) <= a(i) xor b(i);g(i) <= a(i) and b(i);

end generate;

c(0) <= '0';cout <= g(WIDTH-1) or (p(WIDTH-1) and c(WIDTH-1));

cstructure:for i in WIDTH-1 downto 1 generate

c(i) <= g(i-1) or (p(i-1) and c(i-1));end generate;

sstructure:for i in WIDTH-1 downto 0 generate

s(i) <= a(i) xor b(i) xor c(i);end generate;

end;

Mariusz Rawski

Sumator carry lookahead (CLA) – wyniki

Fitter Summary

Top-level Entity Name cla


Device EP1S10F484C5


Total pins 25 / 336 ( 7 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 21

Mnożenie w układzie kombinacyjnym

P = A × B, n = 4

Mi = bi × A ×2i

a3 a2 a1 a0

× b3 b2 b1 b0

0 0 0 0 a3b0 a2b0 a1b0 a0b0 M0

0 0 0 a3b1 a2b1 a1b1 a0b1 0 M1

0 0 a3b2 a2b2 a1b2 a0b2 0 0 M2

0 a3b3 a2b3 a1b3 a0b3 0 0 0 M3

p7 p6 p5 p4 p3 p2 p1 p0

Mnożenie to w zasadzie wielokrotnie wykonywane dodawanie.

Mariusz Rawski 22

dodawanie.

Nowoczesne struktury FPGA

RegReg

RegReg

AdderAdder

AdderAdder12345678

Comb.Logic

AL

M In

pu

ts

ALM

• Linie połączeniowe carry-chain o małych opóźnieniach „spinające” wiele bloków logicznych pozwalają przyspeszyć operacje dodawania i odejmowania

• Względnie wydajne przy realizacji operacji dodawania i odejmowania. Jednakże nie optymalne pod względem kosztu, szybkości i poboru mocy w przypadku realizacji operacji mnożenia i dzielenia

Nowoczesne struktury FPGA

+

Op

tio

nal

Pip

elin

ing

Ou

tpu

t Reg

iste

r U

nit

Ou

tpu

t Mu

ltip

lexe

r

144 144

36

36

36

36

37

37

38

+ - ΣΣΣΣ

+ - ΣΣΣΣInp

ut R

egis

ter

Un

it

• Producenci układów FPGA wbudowują w swoje układy dedykowane bloki realizujące funkcję mnożenia.

• Niektórzy poszli nawet dalej ścieżką integracji udostępniając w pełni funkcjonalne bloki MAC zwane blokami DSP

Operacja dodawania


entity add isgeneric(



);end;

architecture arch of add isarchitecture arch of add is

signal result : unsigned(WIDTH downto 0);

beginresult <= unsigned('0' & a) + unsigned('0' & b);cout <= result(WIDTH);s <= std_logic_vector(result(WIDTH-1 downto 0));

end;

Mariusz Rawski

Kompilator automatycznie wykorzystał mechanizm carry-chain

Operacja dodawania – wyniki

Fitter Summary

Top-level Entity Name add

Family Stratix

Device EP1S10F484C5


Total pins 25 / 336 ( 7 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 26

Najszybsza i najoszczędniejsza realizacja.Realizacja własnego modułu sumatora masens tylko, gdy stosowany jest specyficznyschemat dodawania, np. z wykorzystaniempotokowania lub sumatory wieloargumentowe.

Operacja mnożenia


entity mul isgeneric(


a, b : in std_logic_vector(WIDTH-1 downto 0);p : out std_logic_vector(2*WIDTH-1 downto 0)

);end;architecture arch of mul is

signal result : unsigned(2*WIDTH-1 downto 0);signal result : unsigned(2*WIDTH-1 downto 0);

beginresult <= unsigned(a) * unsigned(b);p <= std_logic_vector(result);

end;

Mariusz Rawski

Kompilator automatycznie wykorzystał wbudowany blok mnożarki

Operacja mnożenia

Fitter Summary

Top-level Entity Name mul

Family Stratix

Device EP1S10F484C5

Total logic elements 0 / 10,570 ( < 1 % )Total logic elements 0 / 10,570 ( < 1 % )

Total pins 32 / 336 ( 9 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 28

Bardzo wydajna realizacja. Gdyby jednak niewykorzystywać dedykowanego blokumnożącego układ zajmowałby 106 komórek atpd wynosiłoby 22,346 ns. Realizacja własnegomodułu mnożącego dopasowanego dokonkretnego algorytmu często prowadzi dolepszych rezultatów.

Obliczanie wartości funkcji w DSP

• W cyfrowym przetwarzaniu sygnałów zazwyczaj nie jest potrzebne wykorzystanie dokładnych wartości funkcji matematycznych takich jak logarytm, pierwiastek czy funkcje trygonometryczne. Zazwyczaj dopuszcza się pewien stopień niedokładności i kładzie się nacisk na szybkość obliczeń

• Stąd też obliczanie przybliżonych wartości funkcji matematycznych jest bardzo ważnym zagadnieniem w DSP

• Jedną z często wykorzystywanych funkcji jest pierwiastek stopnia n (najczęściej pierwiastek kwadratowy).

• Można do tego celu wykorzystać np. szeregi Taylora.

• Jednakże znalezienie wartości np. jest równoznaczne z rozwiązaniem równania

• Stąd też można do tego celu zastosować dowolny algorytm znajdowania miejsca zerowego funkcji taki jak np. metoda Newtona

Mariusz Rawski 29

3 q q x 03 =−

Metoda Newtona

• Zwana również metodą Newtona-Raphsona lub metodą stycznych –iteracyjny algorytm wyznaczania przybliżonej wartości miejsca zerowego funkcji.

• Dla zadanej funkcji ƒ(x) oraz jej pochodnej ƒ '(x), zaczynamy od pierwszego przybliżenia x0. Lepsze przybliżenie x1 otrzymuje się ze wzoru

)('

)(

0

001 xf

xfxx −=

)(' 0xf

Metoda Newtona

Zadanie:

– wyznaczyć wartość

Dla ƒ(x) = x3 – 17,

stąd x1 = x0 – (x03 – 17)/(3* x0

2)

713

713

load = 1

T

N

x = data

start = 1

T

N

cnt = 0

Niech ƒnext(x) = x – (x3 – 17)/(3* x2).

Obliczanie wartości można

przeprowadzić algorytmem iteracyjnym. cnt = 9T

res = x

ready = 1

cnt 0

cnt = cnt + 1

N

x = fnext(x)

713

Metoda Newtona

• Algorytm iteracyjny z wczytaniem

początkowej wartości

• Wynik: liczba 10 bitowa w formacie U2

• Wykorzystanie metodologii RTL• Wykorzystanie metodologii RTL

– konieczna implementacja modułu

realizującego funkcję fnext

– Jest to najbardziej skomplikowana operacja

• Wykorzystanie ASMD

Blok fnext

ƒnext(x) = x – (x3 – 17)/(3* x2)

= x – (x2*x– 17)/(3* x2)

• Blok fnext zostanie zbudowany z następujących elementów:

– power2 – obliczanie x2

– multiply20b – obliczanie x2*x

– multiply_by_3 – obliczanie 3*x2

– divide30b – obliczanie dzielenia

Kolejne przybliżenia reprezentowane są przez 10

bitową liczbę w kodzie U2

x[9..0]

power2_in [9..0]

power2_result [19..0]

multiply_by_3_in [19..0]multiply20b_inA [19..0] multiply20b_inB [9..0]

– divide30b – obliczanie dzielenia

• Bloki power2, multiply20b, multiply_by_3, divide30b zostaną wzięta z biblioteki gotowych komponentów.

Mariusz Rawski 33

multiply_by_3_result [22..0] multiply20b_result [29..0]

divide30b_inA [22..0] divide30b_inB [29..0]

divide30b_result [29..0]

xn[9..0]

Realizacja bloku fnext (1)


entity fnext isgeneric(

number : integer := 1 );port(

x : in std_logic_vector(9 downto 0);xn : out std_logic_vector(9 downto 0)

);end fnext;

architecture structure of fnext is

signal power2_in : std_logic_vector(9 downto 0);

Interfejs układu

Deklaracja sygnałów do połączenia komponentów

Wartość, z której liczony jest pierwiastek

signal power2_in : std_logic_vector(9 downto 0); signal power2_result : std_logic_vector(19 downto 0);

signal multiply20b_inA : std_logic_vector(19 downto 0); signal multiply20b_inB : std_logic_vector(9 downto 0); signal multiply20b_result : std_logic_vector(29 downto 0);

signal multiply_by_3_in : std_logic_vector(19 downto 0); signal multiply_by_3_result: std_logic_vector(22 downto 0);

signal divide30b_inA : std_logic_vector(22 downto 0); signal divide30b_inB : std_logic_vector(29 downto 0); signal divide30b_result : std_logic_vector(29 downto 0);

Mariusz Rawski 34


component power2port(

dataa : in std_logic_vector(9 downto 0);result : out std_logic_vector(19 downto 0)

);end component;

component multiply20bport(

dataa : in std_logic_vector(19 downto 0);datab : in std_logic_vector(9 downto 0);result : out std_logic_vector(29 downto 0)

);end component;

Deklaracja komponentów

component multiply_by_3port(

dataa : in std_logic_vector (19 downt 0);result : out std_logic_vector (22 downt 0)

);end component;

component divide30bport(

denom : in std_logic_vector(22 downto 0);numer : in std_logic_vector(29 downto 0);quotient : out std_logic_vector(29 downto 0);remain : out std_logic_vector(22 downto 0)

);end component;

Mariusz Rawski 35


beginb1 : power2 port map (

dataa => power2_in,result => power2_result

);

b2 : multiply20b port map (dataa => multiply20b_inA,datab => multiply20b_inB,result => multiply20b_result

);

b3 : multiply_by_3 port map (dataa => multiply_by_3_in,result => multiply_by_3_result

);

b4 : divide30b port map(

Konkretyzacja komponentów i podłączenie do sygnałów

b4 : divide30b port map(denom => divide30b_inA,numer => divide30b_inB,quotient => divide30b_result

);

power2_in <= x;multiply_by_3_in <= power2_result;multiply20b_inA <= power2_result;multiply20b_inB <= x;divide30b_inA <= multiply_by_3_result;divide30b_inB <= std_logic_vector(signed(multiply20b_result) –

to_signed(number,30));xn <= std_logic_vector(signed(x) –

signed(divide30b_result(9 downto 0)));

end;

Mariusz Rawski 36

Realizacja bloku fnext – wyniki

Fitter Summary

ƒnext(1) = 1 – (13 – 17)/(3* 12) = 1 – (–5,33) = 6,33 ƒnext(2) = 2 – (23 – 17)/(3* 22) = 2 – (–0,75) = 2,75

Pojawiają się błędy zaokrągleń.

Top-level Entity Name fnext

Family Stratix

Device EP1S10F484C5

Total logic elements 1,133/ 10,570 ( 11 % )

Total pins 20 / 336 ( 6 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 37

Metoda Newtona – ASMD (1)

●●●

entity top isport(

rst : in std_logic;clk : in std_logic;start, load : in std_logic;data : in std_logic_vector(9 downto 0); ready : out std_logic;result : out std_logic_vector(9 downto 0)

);end top;

architecture structure of top isconstant valueToFindTheRootOf : natural := 17;

type STATE_TYPE is (s0, s1, s2, s3, s4, s5, s6);signal state_reg, state_next : STATE_TYPE;

Interfejs

Liczba dla której liczony jest pierwiastek

Stany automatu FSMD

Rejestry modelujące zmienne algorytmu

Sygnały do podłączenia modułu ‘fnext’

signal state_reg, state_next : STATE_TYPE;

signal ready_reg, ready_next : std_logic;signal cnt_reg, cnt_next : unsigned(3 downto 0); signal x_reg, x_next : signed(9 downto 0); signal result_reg, result_next : std_logic_vector(9 downto 0);

signal xn_function_in : std_logic_vector(9 downto 0); signal xn_function_result : std_logic_vector(9 downto 0);

component fnextgeneric(

number : integer := 99 );port(

x : in std_logic_vector(9 downto 0);xn : out std_logic_vector(9 downto 0)

);end component;

Deklaracja komponentu ‘fnext’


beginprocess(clk, rst)begin

if rst = '1' thencnt_reg <= (others => '0');x_reg <= (others => '0');result_reg <= (others => '0');

elsif rising_edge(clk) thencnt_reg <= cnt_next;x_reg <= x_next;result_reg <= result_next;

end if;end process;

process(rst, clk)begin

if rst = '1' thenstate_reg <= s0;

Rejestry modelujące zmienne

Rejestr stanu automatu FSMD

Konkretyzacja komponentu i podłączenie state_reg <= s0;ready_reg <= '0';

elsif rising_edge(clk) thenstate_reg <= state_next;ready_reg <= ready_next;

end if;end process;

xn_function_in <= std_logic_vector(x_reg);b1 : fnext

generic map(number => valueToFindTheRootOf

)port map (

x => xn_function_in,xn => xn_function_result

);

result <= result_reg;ready <= ready_reg;

Konkretyzacja komponentu i podłączenie sygnałów


process(state_reg, start, load, cnt_reg, x_reg, result_reg)begin

ready_next <= '0'; cnt_next <= cnt_reg;x_next <= x_reg; result_next <= result_reg;

case state_reg iswhen s0 =>

if load = '1' then state_next <= s1;else state_next <= s0;end if;

when s1 =>x_next <= signed(data);state_next <= s2;

when s2 =>if start = '1' then state_next <= s3;else state_next <= s2;end if;

when s3 =>

Wartości domyślne

Opis zachowania się automatu FSM i rejestrów zmiennych

when s3 =>cnt_next <= to_unsigned(0, 4);state_next <= s4;

when s4 =>x_next <= signed(xn_function_result);if cnt_reg = 9 then state_next <= s6;else state_next <= s5;end if;

when s5 =>cnt_next <= cnt_reg + 1;state_next <= s4;

when s6 =>result_next <= std_logic_vector(x_reg);ready_next <= '1';state_next <= s0;

when others =>state_next <= s0;

end case;end process;

end;

Realizacja ASMD – wyniki

Układ oblicza wartość z dużym błędem.Dla wynik jest 6 Podczas, gdy prawidłowa

2,571281 713 =

1213

Fitter Summary


Family Stratix

Device EP1S10F484C5


Total pins 25 / 336 ( 7 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 41

Dla wynik jest 6 Podczas, gdy prawidłowa wartość to 4,946087

121

Liczby w notacji stałopozycyjnej (1)

• Liczby– a = 15,671

– b = 2,3

• Suma 1 5 , 6 7 1

+ 2 , 3 0 0

1 7 , 9 7 1

Przy dodawaniu i odejmowaniu należy pamiętać by liczby miały „ustawiony” przecinek w tym samym miejscu.Natomiast przy mnożeniu i dzieleniu należy pamiętać o odpowiednim „ustawieniu” przecinka w wyniku

• Iloczyn

Mariusz Rawski 42

1 5, 6 7 1

× 2, 3

3 6, 0 3 3 3

Liczby w notacji stałopozycyjnej (2)

• Liczby– a = 15,671 → U2Fix5.3 = 01111.101 (15,625)

– b = 2,3 → U2Fix3.5 = 010.01001 (2,28)

• Suma

– a+b → 17,90625 U2Fix5.5

0 1 1 1 1, 1 0 1 0 0

+ 0 1 0, 0 1 0 0 1

1 0 0 0 1, 1 1 1 0 1

Przy dodawaniu i odejmowaniu należy dopasować liczby w zapisie stałopozycyjnym by miały ten sam format („ustawiony” przecinek w tym samym miejscu).

Natomiast przy mnożeniu i dzieleniu należy pamiętać o tym jaki jest format wyniku (odpowiednim „ustawieniu” przecinka w wyniku)

– a+b → 17,90625 U2Fix5.5

• Iloczyn

• a×b → 35,64453125 U2Fix6.8

Mariusz Rawski 43

0 1 1 1 1, 1 0 1

× 0 1 0, 0 1 0 0 1

1 0 0 0 1 1 1, 0 1 0 0 1 0 1

Blok fnext

• Niech x będzie w formacie U2Fix 4.6– power2_result [19..0] → U2Fix 8.12

– multiply_by_3_in [19..0] → U2Fix 8.12

– multiply_by_3_result [22..0] → U2Fix 11.12

– multiply20b_inA [19..0] → U2Fix 8.12

– multiply20b_inB [9..0] → U2Fix 4.6

– multiply20b_result [29..0] → U2Fix 12.18

Kolejne przybliżenia reprezentowane są przez 10

bitową liczbę w kodzie U2Fix4.6

x[9..0]

power2_in [9..0] (4.6)

power2_result [19..0] (8.12)

multiply_by_3_in [19..0] (8.12)multiply20b_inA [19..0] (8.12)

multiply20b_inB [9..0] (4.6)

– divide30b_inA [22..0] → U2Fix 11.12

– divide30b_inB [29..0] → U2Fix 12.18

– divide30b_result [29..0] → U2Fix 24.6

Mariusz Rawski 44

multiply_by_3_result [22..0] (11.12) multiply20b_result [29..0] (12.18)

divide30b_inA [22..0] (11.12) divide30b_inB [29..0] (12.18)

divide30b_result [29..0] (24.6)

xn[9..0]

Należy 17 zapisać w formacie U2Fix12.18

Realizacja bloku fnext – Fix4.6

beginb1 : power2 port map (

dataa => power2_in,result => power2_result

);

b2 : multiply20b port map (dataa => multiply20b_inA,datab => multiply20b_inB,result => multiply20b_result

);

b3 : multiply_by_3 port map (dataa => multiply_by_3_in,result => multiply_by_3_result

);

b4 : divide30b port map(

Nie ma żadnych zmian w użytych komponentach. Operują one na wektorach binarnych

Zapis liczby 17 w formacie U2Fix12.18 –dodanie 18 zer na najmłodszych bitach

b4 : divide30b port map(denom => divide30b_inA,numer => divide30b_inB,quotient => divide30b_result

);

power2_in <= x;multiply_by_3_in <= power2_result;multiply20b_inA <= power2_result;multiply20b_inB <= x;divide30b_inA <= multiply_by_3_result;divide30b_inB <= std_logic_vector(signed(multiply20b_result) –

shift_left(to_signed(number,30), 18));

xn <= std_logic_vector(signed(x) –signed(divide30b_result(9 downto 0)));

end;

Mariusz Rawski 45

Realizacja ASMD – wyniki

165 w zapisie U2Fix4.6 reprezentuje wartość 165/64 = 2.578125.

2,571281 713 =Liczba 1 w U2Fix4.6 to 64

Fitter Summary


Family Stratix

Device EP1S10F484C5


Total pins 25 / 336 ( 7 % )




Total PLLs 0 / 6 ( 0 % )

Total DLLs 0 / 2 ( 0 % )

Mariusz Rawski 46

165/64 = 2.578125.Jest to już znacznie lepsze przybliżenie.

12. cyfrowe przetwarzanie sygnalow(cb)rawski.zpt.tele.pw.edu.pl/pl/system/files/cyfrowe...

Documents