acvarif 0 2 октября, 2013 Опубликовано 2 октября, 2013 (изменено) · Жалоба Как продолжение темы http://electronix.ru/forum/index.php?showtopic=115167 - в архиве fft32stream.rar VHDL код БПФ32 на базе ДСП блоков и регистров + файл симулятора для Quartus 90. Данные загружаются в регистровый файл. Все выполнено на базе 4_х комплексных умножителей + сумматоры. Данные в них последовательно загружаются и выгружаются выполняя алгоритм прореживания по времени. Преобразование после полной загрузки данных (так было необходимо для моей конкретной задачи) занимает 70 тактов. Далее выгрузка 32 такта. В симуляторе подается sin cos - получаем всплеск на одном из выходов. Просьба выразить замечания и предложения по коду. library IEEE; use IEEE.STD_LOGIC_1164.ALL; --use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_SIGNED.ALL; use IEEE.numeric_std.all; entity fft32stream is Generic ( -- размерность входных данных b32_size : natural := 16; -- размерность пов. множит w32_size: natural := 12; -- размерность fft fft_size: natural := 32 ); Port ( -- тактовая частота clk : in std_logic; -- общий сброс rst : in std_logic; -- переключатель входа rel img dir : in std_logic; -- импульс записи данных load : in std_logic; -- строб разрешения зап. данных ready : in std_logic; -- вход данных din : in std_logic_vector(b32_size-1 downto 0); -- выход счетчика стадий ctf32out : out std_logic_vector(6 downto 0); cnt_res_out : out std_logic_vector(5 downto 0); -- тактовая чтения результатов clk_rd_out : out std_logic; clk_wr_out : out std_logic; -- выходные данные dout_re : out std_logic_vector(b32_size-1 downto 0); dout_im : out std_logic_vector(b32_size-1 downto 0) ); end fft32stream; architecture behavioural of fft32stream is attribute multstyle : string; -- на базе логики --attribute multstyle of behavioural : architecture is "logic"; -- на базе встроенных умножителей attribute multstyle of behavioural : architecture is "dsp"; ------------------------------------------------------------- -- сигналы -- счетчик загрузки signal ctrd : std_logic_vector(5 downto 0); -- счетчик стадий signal s_ctf32 : std_logic_vector(6 downto 0); -- счетчик результатов signal s_res : std_logic_vector(5 downto 0); -- флаг завершения загрузки signal endrd : std_logic; -- флаг начала загрузки signal begrd : std_logic; -- флаг начала преобразования signal begpr : std_logic; -- signal s_stop_fft32 : std_logic; signal s_strob_wr : std_logic; signal s_clk_wr : std_logic; ------------------------------------------------------------- -- сигналы входные реал subtype sdr is std_logic_vector(b32_size-1 downto 0); type memory_sdr is array(fft_size-1 downto 0) of sdr; signal s_din_re : memory_sdr; -- сигналы входные мним subtype sdi is std_logic_vector(b32_size-1 downto 0); type memory_sdi is array(fft_size-1 downto 0) of sdi; signal s_din_im : memory_sdi; ------------------------------------------------------------- -- выходные сигн. реал subtype out32re is signed(b32_size-1 downto 0); type memory_out32re is array(fft_size-1 downto 0) of out32re; signal s_32_re : memory_out32re; -- выходные сигн. мним subtype out32im is signed(b32_size-1 downto 0); type memory_out32im is array(fft_size-1 downto 0) of out32im; signal s_32_im : memory_out32im; ------------------------------------------------------------- -- сигналы суммы 4_й стадии реал subtype sum4_re is signed(b32_size-1 downto 0); type memory_sum4_re is array(15 downto 0) of sum4_re; signal s_in4_re : memory_sum4_re; -- сигналы суммы 4_й стадии мним subtype sum4_im is signed(b32_size-1 downto 0); type memory_sum4_im is array(15 downto 0) of sum4_im; signal s_in4_im : memory_sum4_im; -- сигналы суммы 5_й стадии реал subtype sum5_re is signed(b32_size-1 downto 0); type memory_sum5_re is array(fft_size-1 downto 0) of sum5_re; signal s_in5_re : memory_sum5_re; -- сигналы суммы 5_й стадии мним subtype sum5_im is signed(b32_size-1 downto 0); type memory_sum5_im is array(fft_size-1 downto 0) of sum5_im; signal s_in5_im : memory_sum5_im; ------------------------------------------------------------- -- выход умножителя реал subtype mult_re_out is signed(b32_size + w32_size downto 0); type memory_mult_re_out is array(3 downto 0) of mult_re_out; signal s_mult_re_out : memory_mult_re_out; -- выход умножителя мним subtype mult_im_out is signed(b32_size + w32_size downto 0); type memory_mult_im_out is array(3 downto 0) of mult_im_out; signal s_mult_im_out : memory_mult_im_out; -- данные входные умножителя реал subtype mult_re_in is signed(b32_size-1 downto 0); type memory_mult_re_in is array(3 downto 0) of mult_re_in; signal s_mult_re_in : memory_mult_re_in; -- данные входные умножителя мним subtype mult_im_in is signed(b32_size-1 downto 0); type memory_mult_im_in is array(3 downto 0) of mult_im_in; signal s_mult_im_in : memory_mult_im_in; -- коэфф. входные умножителя реал subtype w_mult_re_32 is signed(w32_size-1 downto 0); type memory_w_mult_re_32 is array(3 downto 0) of w_mult_re_32; signal s_w_mult_re_32 : memory_w_mult_re_32; -- коэфф. входные умножителя мним subtype w_mult_im_32 is signed(w32_size-1 downto 0); type memory_w_mult_im_32 is array(3 downto 0) of w_mult_im_32; signal s_w_mult_im_32 : memory_w_mult_im_32; -- данные входные сумматора реал subtype sum_re_in is signed(b32_size-1 downto 0); type memory_sum_re_in is array(3 downto 0) of mult_re_in; signal s_sum_re_in : memory_sum_re_in; -- данные входные сумматора мним subtype sum_im_in is signed(b32_size-1 downto 0); type memory_sum_im_in is array(3 downto 0) of sum_im_in; signal s_sum_im_in : memory_sum_im_in; -- данные выходные сумматора реал subtype sum_re_out is signed(b32_size-1 downto 0); type memory_sum_re_out is array(7 downto 0) of sum_re_out; signal s_sum_re_out : memory_sum_re_out; -- данные выходные сумматора мним subtype sum_im_out is signed(b32_size-1 downto 0); type memory_sum_im_out is array(7 downto 0) of sum_im_out; signal s_sum_im_out : memory_sum_im_out; ------------------------------------------------------------- -- поворачивающие множители -- round(cos(2*pi*n/32)*1024) -- -round(sin(2*pi*n/32)*1024) -- n = 0...15 -- реал constant c_w32_0_re : integer := 1024; constant c_w32_1_re : integer := 1004; constant c_w32_2_re : integer := 946; constant c_w32_3_re : integer := 851; constant c_w32_4_re : integer := 724; constant c_w32_5_re : integer := 569; constant c_w32_6_re : integer := 392; constant c_w32_7_re : integer := 200; constant c_w32_8_re : integer := 0; constant c_w32_9_re : integer := -200; constant c_w32_10_re : integer := -392; constant c_w32_11_re : integer := -569; constant c_w32_12_re : integer := -724; constant c_w32_13_re : integer := -851; constant c_w32_14_re : integer := -946; constant c_w32_15_re : integer := -1004; -- мним constant c_w32_0_im : integer := 0; constant c_w32_1_im : integer := -200; constant c_w32_2_im : integer := -392; constant c_w32_3_im : integer := -569; constant c_w32_4_im : integer := -724; constant c_w32_5_im : integer := -851; constant c_w32_6_im : integer := -946; constant c_w32_7_im : integer := -1004; constant c_w32_8_im : integer := -1024; constant c_w32_9_im : integer := -1004; constant c_w32_10_im : integer := -946; constant c_w32_11_im : integer := -851; constant c_w32_12_im : integer := -724; constant c_w32_13_im : integer := -569; constant c_w32_14_im : integer := -392; constant c_w32_15_im : integer := -200; begin ------------------------------------------------------------- -- загрузка данных в регистровый файл -- 64 положит. импульса load process(clk ) begin if clk'event and clk = '1' then if rst = '0' or begrd = '0' then ctrd <= (others => '0'); endrd <= '0'; begrd <= '1'; elsif ready = '1' then if load = '1' then ctrd <= ctrd + 1; if dir = '1' then s_din_re(31) <= din; for i in 30 downto 0 loop s_din_re(i) <= s_din_re(i+1); end loop; else s_din_im(31) <= din; for i in 30 downto 0 loop s_din_im(i) <= s_din_im(i+1); end loop; end if; -- загрузка завершена if ctrd = 63 then endrd <= '1'; begrd <= '0'; end if; end if; end if; end if; end process; ------------------------------------------------------------- ctf32out <= s_ctf32; cnt_res_out <= s_res; s_clk_wr <= s_strob_wr and clk; clk_wr_out <= s_clk_wr; -- -- данные на выход -- process(s_ctf32, s_32_re, s_32_im,s_strob_wr) -- begin -- case s_strob_wr is -- when '1' => -- dout_re <= std_logic_vector(s_32_re(conv_integer(s_ctf32))); -- dout_im <= std_logic_vector(s_32_im(conv_integer(s_ctf32))); -- when '0' => -- dout_re <= (others => '0'); -- dout_im <= (others => '0'); -- end case; -- end process; -- данные на выход process(s_res, s_32_re, s_32_im,s_strob_wr) begin case s_strob_wr is when '1' => dout_re <= std_logic_vector(s_32_re(conv_integer(s_res))); dout_im <= std_logic_vector(s_32_im(conv_integer(s_res))); when '0' => dout_re <= (others => '0'); dout_im <= (others => '0'); end case; end process; ------------------------------------------------------------- -- Операции БПФ32 process(clk, s_ctf32) begin if clk'event and clk = '0' then if rst = '0' then s_ctf32 <= (others => '0'); -- обнулить флаг конца преобр. s_stop_fft32 <= '0'; -- если все загружено elsif endrd = '1' then -- устан. флаг разр. нач. преобр. begpr <= '1'; -- флаг нач. выгр. в 0 s_strob_wr <= '0'; end if; if begpr = '1' then ------------------------------------------------------------- -- счетчик операций s_ctf32 <= s_ctf32 + 1; ------------------------------------------------------------- -- если конец преобр. if s_stop_fft32 = '1' then -- обнулить флаг начала пр. begpr <= '0'; -- обнулить флаг конца преобр. s_stop_fft32 <= '0'; s_ctf32 <= (others => '0'); -- разрешение выгрузки результ. s_strob_wr <= '1'; end if; end if; -- выгрузка результатов if s_strob_wr = '1' then s_res <= s_res + 1; if s_res = 31 then -- результаты готовы для чтения s_strob_wr <= '0'; s_res <= (others => '0'); end if; end if; -- -- выгрузка результатов -- if s_strob_wr = '1' then -- s_ctf32 <= s_ctf32 + 1; -- if s_ctf32 = 31 then -- -- результаты готовы для чтения -- s_strob_wr <= '0'; -- s_ctf32 <= (others => '0'); -- end if; -- end if; ------------------------------------------------------------- -- начало преобразования ------------------------------------------------------------- if s_ctf32 = 0 then ------------------------------------------------------------- -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= signed(s_din_re(16)); s_mult_re_in(1) <= signed(s_din_re(24)); s_mult_re_in(2) <= signed(s_din_re(20)); s_mult_re_in(3) <= signed(s_din_re(28)); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= signed(s_din_im(16)); s_mult_im_in(1) <= signed(s_din_im(24)); s_mult_im_in(2) <= signed(s_din_im(20)); s_mult_im_in(3) <= signed(s_din_im(28)); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= signed(s_din_re(0)); s_sum_re_in(1) <= signed(s_din_re(8)); s_sum_re_in(2) <= signed(s_din_re(4)); s_sum_re_in(3) <= signed(s_din_re(12)); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= signed(s_din_im(0)); s_sum_im_in(1) <= signed(s_din_im(8)); s_sum_im_in(2) <= signed(s_din_im(4)); s_sum_im_in(3) <= signed(s_din_im(12)); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_0_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_0_im, w32_size); ------------------------------------------------------------- -- комплексный умножитель 4x4 (результат в b32_size + w32_size + 1) ------------------------------------------------------------- elsif s_ctf32 = 2 or -- ok s_ctf32 = 5 or -- ok s_ctf32 = 8 or -- ok s_ctf32 = 12 or -- ok s_ctf32 = 15 or -- ok s_ctf32 = 18 or -- ok s_ctf32 = 22 or -- ok s_ctf32 = 26 or -- ok s_ctf32 = 29 or -- ok s_ctf32 = 32 or -- ok s_ctf32 = 35 or -- ok s_ctf32 = 39 or -- ok s_ctf32 = 42 or -- ok s_ctf32 = 45 or -- ok s_ctf32 = 49 or -- ok s_ctf32 = 53 or -- ok s_ctf32 = 57 or -- ok s_ctf32 = 60 or -- ok s_ctf32 = 63 or -- ok s_ctf32 = 66 -- ok then -- 1_я бабочка s_mult_re_out(0) <= resize((s_mult_re_in(0)*s_w_mult_re_32(0) - s_mult_im_in(0)*s_w_mult_im_32(0)), b32_size + w32_size + 1); s_mult_im_out(0) <= resize((s_mult_re_in(0)*s_w_mult_im_32(0) + s_mult_im_in(0)*s_w_mult_re_32(0)), b32_size + w32_size + 1); -- 2_я бабочка s_mult_re_out(1) <= resize((s_mult_re_in(1)*s_w_mult_re_32(1) - s_mult_im_in(1)*s_w_mult_im_32(1)), b32_size + w32_size + 1); s_mult_im_out(1) <= resize((s_mult_re_in(1)*s_w_mult_im_32(1) + s_mult_im_in(1)*s_w_mult_re_32(1)), b32_size + w32_size + 1); -- 3_я бабочка s_mult_re_out(2) <= resize((s_mult_re_in(2)*s_w_mult_re_32(2) - s_mult_im_in(2)*s_w_mult_im_32(2)), b32_size + w32_size + 1); s_mult_im_out(2) <= resize((s_mult_re_in(2)*s_w_mult_im_32(2) + s_mult_im_in(2)*s_w_mult_re_32(2)), b32_size + w32_size + 1); -- 4_я бабочка s_mult_re_out(3) <= resize((s_mult_re_in(3)*s_w_mult_re_32(3) - s_mult_im_in(3)*s_w_mult_im_32(3)), b32_size + w32_size + 1); s_mult_im_out(3) <= resize((s_mult_re_in(3)*s_w_mult_im_32(3) + s_mult_im_in(3)*s_w_mult_re_32(3)), b32_size + w32_size + 1); ------------------------------------------------------------- -- комплексный сумматор 8x8 (результат в b32_size-1 ) ------------------------------------------------------------- elsif s_ctf32 = 3 or -- ok s_ctf32 = 6 or -- ok s_ctf32 = 9 or -- ok s_ctf32 = 13 or -- ok s_ctf32 = 16 or -- ok s_ctf32 = 19 or -- ok s_ctf32 = 23 or -- ok s_ctf32 = 27 or -- ok s_ctf32 = 30 or -- ok s_ctf32 = 33 or -- ok s_ctf32 = 36 or -- ok s_ctf32 = 40 or -- ok s_ctf32 = 43 or -- ok s_ctf32 = 46 or -- ok s_ctf32 = 50 or -- ok s_ctf32 = 54 or -- ok s_ctf32 = 58 or -- ok s_ctf32 = 61 or -- ok s_ctf32 = 64 or -- ok s_ctf32 = 67 -- ok then -- 0_й выход s_sum_re_out(0) <= s_sum_re_in(0) + s_mult_re_out(0)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(0) <= s_sum_im_in(0) + s_mult_im_out(0)(b32_size + w32_size - 3 downto w32_size - 2); -- 1_й выход s_sum_re_out(1) <= s_sum_re_in(0) - s_mult_re_out(0)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(1) <= s_sum_im_in(0) - s_mult_im_out(0)(b32_size + w32_size - 3 downto w32_size - 2); -- 2_й выход s_sum_re_out(2) <= s_sum_re_in(1) + s_mult_re_out(1)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(2) <= s_sum_im_in(1) + s_mult_im_out(1)(b32_size + w32_size - 3 downto w32_size - 2); -- 3_й выход s_sum_re_out(3) <= s_sum_re_in(1) - s_mult_re_out(1)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(3) <= s_sum_im_in(1) - s_mult_im_out(1)(b32_size + w32_size - 3 downto w32_size - 2); -- 4_й выход s_sum_re_out(4) <= s_sum_re_in(2) + s_mult_re_out(2)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(4) <= s_sum_im_in(2) + s_mult_im_out(2)(b32_size + w32_size - 3 downto w32_size - 2); -- 5_й выход s_sum_re_out(5) <= s_sum_re_in(2) - s_mult_re_out(2)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(5) <= s_sum_im_in(2) - s_mult_im_out(2)(b32_size + w32_size - 3 downto w32_size - 2); -- 6_й выход s_sum_re_out(6) <= s_sum_re_in(3) + s_mult_re_out(3)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(6) <= s_sum_im_in(3) + s_mult_im_out(3)(b32_size + w32_size - 3 downto w32_size - 2); -- 7_й выход s_sum_re_out(7) <= s_sum_re_in(3) - s_mult_re_out(3)(b32_size + w32_size - 3 downto w32_size - 2); s_sum_im_out(7) <= s_sum_im_in(3) - s_mult_im_out(3)(b32_size + w32_size - 3 downto w32_size - 2); ------------------------------------------------------------- ------------------------------------------------------------- elsif s_ctf32 = 4 or -- ok s_ctf32 = 14 or -- ok s_ctf32 = 31 or -- ok s_ctf32 = 41 -- ok then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_sum_re_out(2); s_mult_re_in(1) <= s_sum_re_out(3); s_mult_re_in(2) <= s_sum_re_out(6); s_mult_re_in(3) <= s_sum_re_out(7); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_sum_im_out(2); s_mult_im_in(1) <= s_sum_im_out(3); s_mult_im_in(2) <= s_sum_im_out(6); s_mult_im_in(3) <= s_sum_im_out(7); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_sum_re_out(0); s_sum_re_in(1) <= s_sum_re_out(1); s_sum_re_in(2) <= s_sum_re_out(4); s_sum_re_in(3) <= s_sum_re_out(5); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_sum_im_out(0); s_sum_im_in(1) <= s_sum_im_out(1); s_sum_im_in(2) <= s_sum_im_out(4); s_sum_im_in(3) <= s_sum_im_out(5); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_8_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_8_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_8_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_8_im, w32_size); elsif s_ctf32 = 7 or -- ok s_ctf32 = 17 or -- ok s_ctf32 = 34 or -- ok s_ctf32 = 44 -- ok then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_sum_re_out(4); s_mult_re_in(1) <= s_sum_re_out(6); s_mult_re_in(2) <= s_sum_re_out(5); s_mult_re_in(3) <= s_sum_re_out(7); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_sum_im_out(4); s_mult_im_in(1) <= s_sum_im_out(6); s_mult_im_in(2) <= s_sum_im_out(5); s_mult_im_in(3) <= s_sum_im_out(7); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_sum_re_out(0); s_sum_re_in(1) <= s_sum_re_out(2); s_sum_re_in(2) <= s_sum_re_out(1); s_sum_re_in(3) <= s_sum_re_out(3); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_sum_im_out(0); s_sum_im_in(1) <= s_sum_im_out(2); s_sum_im_in(2) <= s_sum_im_out(1); s_sum_im_in(3) <= s_sum_im_out(3); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_4_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_8_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_12_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_4_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_8_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_12_im, w32_size); elsif s_ctf32 = 10 or -- ok s_ctf32 = 37 -- ok then -- выгрузка реал данных сумматора s_in4_re(0) <= s_sum_re_out(0); s_in4_re(1) <= s_sum_re_out(2); s_in4_re(2) <= s_sum_re_out(4); s_in4_re(3) <= s_sum_re_out(6); s_in4_re(4) <= s_sum_re_out(1); s_in4_re(5) <= s_sum_re_out(3); s_in4_re(6) <= s_sum_re_out(5); s_in4_re(7) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_in4_im(0) <= s_sum_im_out(0); s_in4_im(1) <= s_sum_im_out(2); s_in4_im(2) <= s_sum_im_out(4); s_in4_im(3) <= s_sum_im_out(6); s_in4_im(4) <= s_sum_im_out(1); s_in4_im(5) <= s_sum_im_out(3); s_in4_im(6) <= s_sum_im_out(5); s_in4_im(7) <= s_sum_im_out(7); elsif s_ctf32 = 11 -- then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= signed(s_din_re(18)); s_mult_re_in(1) <= signed(s_din_re(26)); s_mult_re_in(2) <= signed(s_din_re(22)); s_mult_re_in(3) <= signed(s_din_re(30)); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= signed(s_din_im(18)); s_mult_im_in(1) <= signed(s_din_im(26)); s_mult_im_in(2) <= signed(s_din_im(22)); s_mult_im_in(3) <= signed(s_din_im(30)); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= signed(s_din_re(2)); s_sum_re_in(1) <= signed(s_din_re(10)); s_sum_re_in(2) <= signed(s_din_re(6)); s_sum_re_in(3) <= signed(s_din_re(14)); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= signed(s_din_im(2)); s_sum_im_in(1) <= signed(s_din_im(10)); s_sum_im_in(2) <= signed(s_din_im(6)); s_sum_im_in(3) <= signed(s_din_im(14)); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_0_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_0_im, w32_size); elsif s_ctf32 = 20 or -- ok s_ctf32 = 47 -- ok then -- выгрузка реал данных сумматора s_in4_re(8) <= s_sum_re_out(0); s_in4_re(9) <= s_sum_re_out(2); s_in4_re(10) <= s_sum_re_out(4); s_in4_re(11) <= s_sum_re_out(6); s_in4_re(12) <= s_sum_re_out(1); s_in4_re(13) <= s_sum_re_out(3); s_in4_re(14) <= s_sum_re_out(5); s_in4_re(15) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_in4_im(8) <= s_sum_im_out(0); s_in4_im(9) <= s_sum_im_out(2); s_in4_im(10) <= s_sum_im_out(4); s_in4_im(11) <= s_sum_im_out(6); s_in4_im(12) <= s_sum_im_out(1); s_in4_im(13) <= s_sum_im_out(3); s_in4_im(14) <= s_sum_im_out(5); s_in4_im(15) <= s_sum_im_out(7); elsif s_ctf32 = 21 or -- ok s_ctf32 = 48 -- ok then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_in4_re(8); s_mult_re_in(1) <= s_in4_re(9); s_mult_re_in(2) <= s_in4_re(10); s_mult_re_in(3) <= s_in4_re(11); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_in4_im(8); s_mult_im_in(1) <= s_in4_im(9); s_mult_im_in(2) <= s_in4_im(10); s_mult_im_in(3) <= s_in4_im(11); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_in4_re(0); s_sum_re_in(1) <= s_in4_re(1); s_sum_re_in(2) <= s_in4_re(2); s_sum_re_in(3) <= s_in4_re(3); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_in4_im(0); s_sum_im_in(1) <= s_in4_im(1); s_sum_im_in(2) <= s_in4_im(2); s_sum_im_in(3) <= s_in4_im(3); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_2_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_4_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_6_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_2_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_4_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_6_im, w32_size); elsif s_ctf32 = 24 -- ok then -- выгрузка реал данных сумматора s_in5_re(0) <= s_sum_re_out(0); s_in5_re(8) <= s_sum_re_out(1); s_in5_re(1) <= s_sum_re_out(2); s_in5_re(9) <= s_sum_re_out(3); s_in5_re(2) <= s_sum_re_out(4); s_in5_re(10) <= s_sum_re_out(5); s_in5_re(3) <= s_sum_re_out(6); s_in5_re(11) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_in5_im(0) <= s_sum_im_out(0); s_in5_im(8) <= s_sum_im_out(1); s_in5_im(1) <= s_sum_im_out(2); s_in5_im(9) <= s_sum_im_out(3); s_in5_im(2) <= s_sum_im_out(4); s_in5_im(10) <= s_sum_im_out(5); s_in5_im(3) <= s_sum_im_out(6); s_in5_im(11) <= s_sum_im_out(7); elsif s_ctf32 = 25 or -- ok --------------------------------------- s_ctf32 = 52 -- ok then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_in4_re(12); s_mult_re_in(1) <= s_in4_re(13); s_mult_re_in(2) <= s_in4_re(14); s_mult_re_in(3) <= s_in4_re(15); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_in4_im(12); s_mult_im_in(1) <= s_in4_im(13); s_mult_im_in(2) <= s_in4_im(14); s_mult_im_in(3) <= s_in4_im(15); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_in4_re(4); s_sum_re_in(1) <= s_in4_re(5); s_sum_re_in(2) <= s_in4_re(6); s_sum_re_in(3) <= s_in4_re(7); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_in4_im(4); s_sum_im_in(1) <= s_in4_im(5); s_sum_im_in(2) <= s_in4_im(6); s_sum_im_in(3) <= s_in4_im(7); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_8_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_10_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_12_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_14_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_8_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_10_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_12_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_14_im, w32_size); elsif s_ctf32 = 28 then -- выгрузка реал данных сумматора s_in5_re(4) <= s_sum_re_out(0); s_in5_re(12) <= s_sum_re_out(1); s_in5_re(5) <= s_sum_re_out(2); s_in5_re(13) <= s_sum_re_out(3); s_in5_re(6) <= s_sum_re_out(4); s_in5_re(14) <= s_sum_re_out(5); s_in5_re(7) <= s_sum_re_out(6); s_in5_re(15) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_in5_im(4) <= s_sum_im_out(0); s_in5_im(12) <= s_sum_im_out(1); s_in5_im(5) <= s_sum_im_out(2); s_in5_im(13) <= s_sum_im_out(3); s_in5_im(6) <= s_sum_im_out(4); s_in5_im(14) <= s_sum_im_out(5); s_in5_im(7) <= s_sum_im_out(6); s_in5_im(15) <= s_sum_im_out(7); -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= signed(s_din_re(17)); s_mult_re_in(1) <= signed(s_din_re(25)); s_mult_re_in(2) <= signed(s_din_re(21)); s_mult_re_in(3) <= signed(s_din_re(29)); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= signed(s_din_im(17)); s_mult_im_in(1) <= signed(s_din_im(25)); s_mult_im_in(2) <= signed(s_din_im(21)); s_mult_im_in(3) <= signed(s_din_im(29)); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= signed(s_din_re(1)); s_sum_re_in(1) <= signed(s_din_re(9)); s_sum_re_in(2) <= signed(s_din_re(5)); s_sum_re_in(3) <= signed(s_din_re(13)); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= signed(s_din_im(1)); s_sum_im_in(1) <= signed(s_din_im(9)); s_sum_im_in(2) <= signed(s_din_im(5)); s_sum_im_in(3) <= signed(s_din_im(13)); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_0_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_0_im, w32_size); elsif s_ctf32 = 38 -- ok then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= signed(s_din_re(19)); s_mult_re_in(1) <= signed(s_din_re(27)); s_mult_re_in(2) <= signed(s_din_re(23)); s_mult_re_in(3) <= signed(s_din_re(31)); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= signed(s_din_im(19)); s_mult_im_in(1) <= signed(s_din_im(27)); s_mult_im_in(2) <= signed(s_din_im(23)); s_mult_im_in(3) <= signed(s_din_im(31)); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= signed(s_din_re(3)); s_sum_re_in(1) <= signed(s_din_re(11)); s_sum_re_in(2) <= signed(s_din_re(7)); s_sum_re_in(3) <= signed(s_din_re(15)); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= signed(s_din_im(3)); s_sum_im_in(1) <= signed(s_din_im(11)); s_sum_im_in(2) <= signed(s_din_im(7)); s_sum_im_in(3) <= signed(s_din_im(15)); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_0_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_0_im, w32_size); elsif s_ctf32 = 51 -- ok then -- выгрузка реал данных сумматора s_in5_re(16) <= s_sum_re_out(0); s_in5_re(24) <= s_sum_re_out(1); s_in5_re(17) <= s_sum_re_out(2); s_in5_re(25) <= s_sum_re_out(3); s_in5_re(18) <= s_sum_re_out(4); s_in5_re(26) <= s_sum_re_out(5); s_in5_re(19) <= s_sum_re_out(6); s_in5_re(27) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_in5_im(16) <= s_sum_im_out(0); s_in5_im(24) <= s_sum_im_out(1); s_in5_im(17) <= s_sum_im_out(2); s_in5_im(25) <= s_sum_im_out(3); s_in5_im(18) <= s_sum_im_out(4); s_in5_im(26) <= s_sum_im_out(5); s_in5_im(19) <= s_sum_im_out(6); s_in5_im(27) <= s_sum_im_out(7); elsif s_ctf32 = 55 -- ok then -- выгрузка реал данных сумматора s_in5_re(20) <= s_sum_re_out(0); s_in5_re(28) <= s_sum_re_out(1); s_in5_re(21) <= s_sum_re_out(2); s_in5_re(29) <= s_sum_re_out(3); s_in5_re(22) <= s_sum_re_out(4); s_in5_re(30) <= s_sum_re_out(5); s_in5_re(23) <= s_sum_re_out(6); s_in5_re(31) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_in5_im(20) <= s_sum_im_out(0); s_in5_im(28) <= s_sum_im_out(1); s_in5_im(21) <= s_sum_im_out(2); s_in5_im(29) <= s_sum_im_out(3); s_in5_im(22) <= s_sum_im_out(4); s_in5_im(30) <= s_sum_im_out(5); s_in5_im(23) <= s_sum_im_out(6); s_in5_im(31) <= s_sum_im_out(7); ------------------------------------------------------------- ------------------------------------------------------------- -- ПЯТАЯ СТАДИЯ ------------------------------------------------------------- ------------------------------------------------------------- elsif s_ctf32 = 56 then -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_in5_re(16); s_mult_re_in(1) <= s_in5_re(17); s_mult_re_in(2) <= s_in5_re(18); s_mult_re_in(3) <= s_in5_re(19); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_in5_im(16); s_mult_im_in(1) <= s_in5_im(17); s_mult_im_in(2) <= s_in5_im(18); s_mult_im_in(3) <= s_in5_im(19); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_in5_re(0); s_sum_re_in(1) <= s_in5_re(1); s_sum_re_in(2) <= s_in5_re(2); s_sum_re_in(3) <= s_in5_re(3); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_in5_im(0); s_sum_im_in(1) <= s_in5_im(1); s_sum_im_in(2) <= s_in5_im(2); s_sum_im_in(3) <= s_in5_im(3); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_0_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_1_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_2_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_3_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_0_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_1_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_2_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_3_im, w32_size); elsif s_ctf32 = 59 then -- выгрузка реал данных сумматора s_32_re(0) <= s_sum_re_out(0); s_32_re(16) <= s_sum_re_out(1); s_32_re(1) <= s_sum_re_out(2); s_32_re(17) <= s_sum_re_out(3); s_32_re(2) <= s_sum_re_out(4); s_32_re(18) <= s_sum_re_out(5); s_32_re(3) <= s_sum_re_out(6); s_32_re(19) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_32_im(0) <= s_sum_im_out(0); s_32_im(16) <= s_sum_im_out(1); s_32_im(1) <= s_sum_im_out(2); s_32_im(17) <= s_sum_im_out(3); s_32_im(2) <= s_sum_im_out(4); s_32_im(18) <= s_sum_im_out(5); s_32_im(3) <= s_sum_im_out(6); s_32_im(19) <= s_sum_im_out(7); -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_in5_re(20); s_mult_re_in(1) <= s_in5_re(21); s_mult_re_in(2) <= s_in5_re(22); s_mult_re_in(3) <= s_in5_re(23); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_in5_im(20); s_mult_im_in(1) <= s_in5_im(21); s_mult_im_in(2) <= s_in5_im(22); s_mult_im_in(3) <= s_in5_im(23); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_in5_re(4); s_sum_re_in(1) <= s_in5_re(5); s_sum_re_in(2) <= s_in5_re(6); s_sum_re_in(3) <= s_in5_re(7); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_in5_im(4); s_sum_im_in(1) <= s_in5_im(5); s_sum_im_in(2) <= s_in5_im(6); s_sum_im_in(3) <= s_in5_im(7); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_4_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_5_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_6_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_7_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_4_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_5_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_6_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_7_im, w32_size); elsif s_ctf32 = 62 then -- выгрузка реал данных сумматора s_32_re(4) <= s_sum_re_out(0); s_32_re(20) <= s_sum_re_out(1); s_32_re(5) <= s_sum_re_out(2); s_32_re(21) <= s_sum_re_out(3); s_32_re(6) <= s_sum_re_out(4); s_32_re(22) <= s_sum_re_out(5); s_32_re(7) <= s_sum_re_out(6); s_32_re(23) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_32_im(4) <= s_sum_im_out(0); s_32_im(20) <= s_sum_im_out(1); s_32_im(5) <= s_sum_im_out(2); s_32_im(21) <= s_sum_im_out(3); s_32_im(6) <= s_sum_im_out(4); s_32_im(22) <= s_sum_im_out(5); s_32_im(7) <= s_sum_im_out(6); s_32_im(23) <= s_sum_im_out(7); -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_in5_re(24); s_mult_re_in(1) <= s_in5_re(25); s_mult_re_in(2) <= s_in5_re(26); s_mult_re_in(3) <= s_in5_re(27); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_in5_im(24); s_mult_im_in(1) <= s_in5_im(25); s_mult_im_in(2) <= s_in5_im(26); s_mult_im_in(3) <= s_in5_im(27); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_in5_re(8); s_sum_re_in(1) <= s_in5_re(9); s_sum_re_in(2) <= s_in5_re(10); s_sum_re_in(3) <= s_in5_re(11); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_in5_im(8); s_sum_im_in(1) <= s_in5_im(9); s_sum_im_in(2) <= s_in5_im(10); s_sum_im_in(3) <= s_in5_im(11); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_8_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_9_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_10_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_11_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_8_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_9_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_10_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_11_im, w32_size); elsif s_ctf32 = 65 then -- выгрузка реал данных сумматора s_32_re(8) <= s_sum_re_out(0); s_32_re(24) <= s_sum_re_out(1); s_32_re(9) <= s_sum_re_out(2); s_32_re(25) <= s_sum_re_out(3); s_32_re(10) <= s_sum_re_out(4); s_32_re(26) <= s_sum_re_out(5); s_32_re(11) <= s_sum_re_out(6); s_32_re(27) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_32_im(8) <= s_sum_im_out(0); s_32_im(24) <= s_sum_im_out(1); s_32_im(9) <= s_sum_im_out(2); s_32_im(25) <= s_sum_im_out(3); s_32_im(10) <= s_sum_im_out(4); s_32_im(26) <= s_sum_im_out(5); s_32_im(11) <= s_sum_im_out(6); s_32_im(27) <= s_sum_im_out(7); -- загрузка данных реал для умнож.4х4 s_mult_re_in(0) <= s_in5_re(28); s_mult_re_in(1) <= s_in5_re(29); s_mult_re_in(2) <= s_in5_re(30); s_mult_re_in(3) <= s_in5_re(31); -- загрузка данных мним для умнож.4х4 s_mult_im_in(0) <= s_in5_im(28); s_mult_im_in(1) <= s_in5_im(29); s_mult_im_in(2) <= s_in5_im(30); s_mult_im_in(3) <= s_in5_im(31); -- загрузка данных реал для сумм.8х8 s_sum_re_in(0) <= s_in5_re(12); s_sum_re_in(1) <= s_in5_re(13); s_sum_re_in(2) <= s_in5_re(14); s_sum_re_in(3) <= s_in5_re(15); -- загрузка данных реал для сумм.8х8 s_sum_im_in(0) <= s_in5_im(12); s_sum_im_in(1) <= s_in5_im(13); s_sum_im_in(2) <= s_in5_im(14); s_sum_im_in(3) <= s_in5_im(15); -- загрузка коэфф. реал в умнож.4 s_w_mult_re_32(0) <= to_signed(c_w32_12_re, w32_size); s_w_mult_re_32(1) <= to_signed(c_w32_13_re, w32_size); s_w_mult_re_32(2) <= to_signed(c_w32_14_re, w32_size); s_w_mult_re_32(3) <= to_signed(c_w32_15_re, w32_size); -- загрузка коэфф. мним в умнож.4 s_w_mult_im_32(0) <= to_signed(c_w32_12_im, w32_size); s_w_mult_im_32(1) <= to_signed(c_w32_13_im, w32_size); s_w_mult_im_32(2) <= to_signed(c_w32_14_im, w32_size); s_w_mult_im_32(3) <= to_signed(c_w32_15_im, w32_size); elsif s_ctf32 = 68 then -- выгрузка реал данных сумматора s_32_re(12) <= s_sum_re_out(0); s_32_re(28) <= s_sum_re_out(1); s_32_re(13) <= s_sum_re_out(2); s_32_re(29) <= s_sum_re_out(3); s_32_re(14) <= s_sum_re_out(4); s_32_re(30) <= s_sum_re_out(5); s_32_re(15) <= s_sum_re_out(6); s_32_re(31) <= s_sum_re_out(7); -- выгрузка мним данных сумматора s_32_im(12) <= s_sum_im_out(0); s_32_im(28) <= s_sum_im_out(1); s_32_im(13) <= s_sum_im_out(2); s_32_im(29) <= s_sum_im_out(3); s_32_im(14) <= s_sum_im_out(4); s_32_im(30) <= s_sum_im_out(5); s_32_im(15) <= s_sum_im_out(6); s_32_im(31) <= s_sum_im_out(7); elsif s_ctf32 = 69 then -- конец преобразования s_stop_fft32 <= '1'; end if; end if; end process; ------------------------------------------------------------ end behavioural; Изменено 2 октября, 2013 пользователем Acvarif Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
Sefo 0 2 октября, 2013 Опубликовано 2 октября, 2013 · Жалоба Как продолжение темы http://electronix.ru/forum/index.php?showtopic=115167 - в архиве fft32stream.rar VHDL код БПФ32 на базе ДСП блоков и регистров + файл симулятора для Quartus 90. Данные загружаются в регистровый файл. Все выполнено на базе 4_х комплексных умножителей + сумматоры. Данные в них последовательно загружаются и выгружаются выполняя алгоритм прореживания по времени. Преобразование после полной загрузки данных (так было необходимо для моей конкретной задачи) занимает 70 тактов. Далее выгрузка 32 такта. В симуляторе подается sin cos - получаем всплеск на одном из выходов. Просьба выразить замечания и предложения по коду. Код просто ужасен! Вы только представьте, что было бы, если бы нужно было реализовать БПФ на 1024 точки... Про ресурсы ПЛИС, надеюсь, Вы и сами понимаете, что ваше БПФ сжирает их в каких-то неимоверных количествах! Меня смущает, что БПФ тратит 70 тактов на вычисление. Если я правильно понял, у Вас 1 такт на бабочку и 1 такт на умножение и параллельно вычисляется 4 бабочки и выполняется 4 умножения. Тогда, для вычисления Вам нужно (16*2*5)/4 = 40 тактов. Вы уверены, что все правильно реализовано? Кстати сказать, если учесть значения коэффициентов, то (16*2*5 - 16)/4 = 36 тактов. Я бы рекомендовал Вам просто оценить Ваш код с точки зрения решена или не решена поставленная задача. Если результаты вычисления БПФ позволяют определить угол прихода волны, БПФ укладываются в отведенное время и все помещается в ПЛИС, то лучше на этом и остановиться. Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
acvarif 0 3 октября, 2013 Опубликовано 3 октября, 2013 (изменено) · Жалоба Код просто ужасен! Вы только представьте, что было бы, если бы нужно было реализовать БПФ на 1024 точки... Я бы рекомендовал Вам просто оценить Ваш код с точки зрения решена или не решена поставленная задача. Если результаты вычисления БПФ позволяют определить угол прихода волны, БПФ укладываются в отведенное время и все помещается в ПЛИС, то лучше на этом и остановиться. Про ужасный - думаю не совсем. Код обычный, прямой как двери. Сжирает прилично. С ДСП блоками порядка 4.5 тысяч ячеек. Но другого варианта для моей задачи пока не вижу. Если кто подскажет другое, буду признателен. Про ресурсы ПЛИС, надеюсь, Вы и сами понимаете, что ваше БПФ сжирает их в каких-то неимоверных количествах! Меня смущает, что БПФ тратит 70 тактов на вычисление. Если я правильно понял, у Вас 1 такт на бабочку и 1 такт на умножение и параллельно вычисляется 4 бабочки и выполняется 4 умножения. Тогда, для вычисления Вам нужно (16*2*5)/4 = 40 тактов. Вы уверены, что все правильно реализовано? Кстати сказать, если учесть значения коэффициентов, то (16*2*5 - 16)/4 = 36 тактов 1 такт на умножение (для 4-х бабочек 2х2) и один такт на сумму - на выходе 16 данных (8 реал + 8 мним). Все выполняется последовательно до получения результата. Данные тупо загружаются в одни и те же регистры. выполняется умножение и суммирование, затем при выгрузке результатов одновременно загружаются новые данные для новой операции умножения-суммирования. В коде пропущен такт (потом подправлю). Вообще получается 68 тактов с учетом 0_го. Кстати много (наверняка очень много) ресурсов тратится на операции сравнения с кодом счетчика операций, а не на на сами вычисления. Как от этого уйти пока не знаю. К коду приложен файл для симулятора (открывается в Q9) в котором показано, что все выполняется верно в том числе и с синусной и косинусной составляющими fft32stream.sim.rar Пока меня все устраивает. Если есть другой путь построения бпф (для задачи одновременного приема данных - преобразования - полученияя всех данных в конце преобразования) просьба коротко пояснить. Изменено 3 октября, 2013 пользователем Acvarif Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
acvarif 0 22 октября, 2013 Опубликовано 22 октября, 2013 (изменено) · Жалоба Опробовал код в составе общего проекта с фильтрами. Работает без проблем. Понятно, что таким макаром БПФ не делается. Слишком много ресурсов. Поэтому попытаюсь выполнить БПФ32 на базе гнездового алгоритма (думаю не ошибся с названием), скан прилагается SWScan0000200002.rar Проблема в том, что 8-ми точечный и 4_х точечные БПФ всеравно придется делать обычным способом (в лоб). А этого делать не хочется. В конечном итоге будет та же корова, только вид сбоку. Просьба посоветовать алгоритм FPGA БПФ8 другим способом чем "в лоб". Имеется ввиду блок схему выполнения преобразования с минимумом ресурсов, например с использованием памяти или еще как. Анализ кода из темы http://electronix.ru/forum/index.php?showt...8026&st=315 ничего не дал. Проще говря не понял как все крутится... Изменено 22 октября, 2013 пользователем Acvarif Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
Sefo 0 25 октября, 2013 Опубликовано 25 октября, 2013 · Жалоба Проблема в том, что 8-ми точечный и 4_х точечные БПФ всеравно придется делать обычным способом (в лоб). Объясните, пожалуйста, что именно Вы понимаете под "обычным способом (в лоб)" - прямо скажем, для каждого этот способ свой. Слишком много ресурсов. Поэтому попытаюсь выполнить БПФ32 на базе гнездового алгоритма (думаю не ошибся с названием) Просьба посоветовать алгоритм FPGA БПФ8 другим способом чем "в лоб". Имеется ввиду блок схему выполнения преобразования с минимумом ресурсов, например с использованием памяти или еще как. Я Вам в прошлой теме написал Дискретное преобразование Фурье это вполне конкретная (и довольно компактная) формула. Она может быть вычислена множеством способов. В свою очередь, каждый способ вычислений может иметь множество реализаций. Вы "зациклились" на способе вычисления (алгоритме), однако проблема, которую Вы пытаетесь решить скрывается в реализации алгоритма, а не в самом алгоритме. Используя текущий выбранный вами вариант алгоритма можно его реализовать более оптимально и та же самая схема БПФ будет занимать в ПЛИС гораздо меньше ресурсов, чем ваш код. Поэтому, бесполезно искать другие способы вычисления (алгоритмы) БПФ - нужно оптимизировать имеющийся код. Для того чтобы оптимизировать код по занимаемым ресурсам ПЛИС нужно сначала понять почему код занимает так много ресурсов. Для того, чтобы это понять нарисуйте блок-схему конкретно вашей реализации. Помочь Вам в этом может RTL Viewer Квартуса. Если Вы правильно это сделаете, то уверен, что и сами поймете как сократить количество ресурсов ПЛИС. Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
acvarif 0 30 октября, 2013 Опубликовано 30 октября, 2013 · Жалоба Спасибо. Попробую разобраться в том, что имеется. RTL посмотрел. Похоже место занимают огромные мультиплексоры с компараторами, которые сравнивают текущее состояние счетчика операций и коммутируют очередную порцию данных нат вход вычислителя (умножители+сумматоры) и с его выхода на промежуточные регистры. Пока не могу придумать как все сделать попроще. Все работает вроде не так сложно, но места занимает много. 1. Имеются 4 комплексных умножителя + 8 комплексных сумматоров которые выполняют вычисления на базе 8_ми входных комплексных данных. Результат сохраняется в промежуточных регистрах стадий БПФ. 2. каждое вычисление занимает 2 такта 1 - умножение 2 - суммирование. 3. Данные на вычислитель поступают параллельно согласно состояниям запущенного в самом начале счетчика операций. 4. Выгрузка результата тоже производится согласно определенных состояний счетчика операций. Синхронизация каждой последующей операции с состоянием счетчика операций и коммутация входных и выходных двнных занимают много ресурсов. Что можно предпринять в этом случае? Синхронизация операций с состояниями счетчика операций - куча компараторов. Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
Sefo 0 1 ноября, 2013 Опубликовано 1 ноября, 2013 · Жалоба Синхронизация каждой последующей операции с состоянием счетчика операций и коммутация входных и выходных двнных занимают много ресурсов. Что можно предпринять в этом случае? Как я уже говорил, ваш код анализу за приемлемое время не поддается. После синтеза в RTL Viewer получается такая же каша в которой совершенно невозможно разобраться - только видны какие-то неприлично большие мультиплексоры. Начните с малого - выделите бабочку в отдельный модуль. Это существенно улучшит ситуацию с анализом. Что касается бабочки, то я не вижу смысла вычислять ее за 2 такта. У Вас не те скорости, чтобы делать вычисления с pipeline. Вычисление бабочки за 1 такт должно сэкономить некоторое кол-во ресурсов. Если я правильно понял, то сумматор и умножитель у вас обвешаны регистрами с обеих сторон - это тоже избыточно. Достаточно регистры поставить только на выходе (причем, с учетом предыдущего пункта на выходе бабочки). На входе они не требуются. Нет также необходимости в отдельных фазах "загрузки"и "выгрузки" данных в/из умножители и сумматоры (бабочку). И все же, Вам необходимо, хотя бы просто набросать (без особой детализации) блок-схему именно вашей реализации так, как Вы ее задумывали. Главное показать на ней мультиплексоры и триггеры. Цитата Поделиться сообщением Ссылка на сообщение Поделиться на другие сайты Поделиться
