5.3. Реализация цифровых фильтров на ПЛИС семейства FLEX фирмы ALTERA

Многие ЦФ достаточно просто реализовать в виде КИХ-фильтра. С появлением БИС семейства FLEX8000 и FLEX10K фирмы ALTERA появилась возможность создания высокопроизводительных и гибких КИХ-фильтров высокого порядка. При этом ПЛИС благодаря особенностям своей архитектуры позволяют достигнуть наилучших показателей производительности по сравнению с другими способами реализации ЦФ. Так, при реализации ЦФ на базе ЦПОС среднего класса позволяет достигнуть производительности обработки данных порядка 5 милионнов отсчетов в секунду (MSPS, Million samples per second). Использование готовых специализированных БИС позволяет обеспечить производительность 30-35 MSPS. При использовании ПЛИС семейств FLEX8000 и FLEX10K достигаются величины более 100 MSPS.

Рис.5.1. КИХ-фильтра с 8 отводами

.

Произведение на выходе ПВП принимает вид

Рис. 5.2. Параллельный векторный перемножитель.

Очевидно, что с ростом разрядности представления данных возрастает размерность ТП, а, следовательно, большее число ЛЭ требуется. Для реализации алгоритма фильтрации. Так, для реализации 8-разрядного ПЛП требуется 8 ТП размерностью 16x8. Операция умножения на 2 легко обеспечивается сдвиговыми регистрами.

Включение сдвиговых регистров на выходах промежуточных сумматоров позволяет обеспечить конвейеризацию обработки данных и, следовательно, повысить производительность. При этом регистры входят в состав соответствующих ЛЭ, поэтому сохраняется компактность структуры, не требуется задействовать дополнительные ЛЭ.

Основным достоинством параллельной архитектуры построения фильтров является высокая производительность. Однако, если число задействованных ЛЭ является критичным, предпочтительнее строить фильтр по последовательной или комбинированной архитектуре. В таблице 5.1. приведены сравнительные характеристики КИХ-фильтров одинаковой разрядности и порядка, но выполненных по различной архитектуре.

Одним из эффективных способов повышения производительности фильтра является конвейеризация. В случае, если длина вектора S не является степенью двойки, используются дополнительные регистры для обеспечения синхронизации. С целью построения фильтров более высокого порядка используют последовательное соединение фильтров (каскадирование) меньшего порядка.

Увеличение разрядности данных требует обеспечения большей точности вычислений и разрядности коэффициентов. Увеличение разрядности данных на один бит требует использования дополнительной ТП при параллельной архитектуре и увеличения на один такт времени фильтрации при последовательной архитектуре. При этом для обеспечения достаточной точности представления данных требуется для фильтра 32-го порядка 19-разрядов длины выходного слова при 8-разрядных входных данных.

Построение фильтра нечетного порядка достигается удалением одного из регистров сдвига. Если применять не сумматоры, а вычитатели то легко реализовать фильтр с антисимметричной характеристикой.

Довольно легко реализуются фильтры с прореживанием или, наоборот, с интерполяцией отсчетов. При проектировании прореживающего фильтра обеспечивается покаскадное уменьшение тактовой частоты, что позволяет существенно снизить энергопотребление. Интерполирующий фильтр выполняет противоположную операцию-увеличение частоты выборки в определнное число раз. Одним из способов реализации такого алгоритма является дополнение отсчетов нулями.

Возможности архитектуры ПЛИС семейств FLEX позволяют реализовать двумерные фильтры для обработки изображений, а также решетчатые структуры.

Для проектирования фильтров необходим набор специализированных програмных средств, позволяющих синтезировать требуемую системную функцию фильтра, провести моделирование его работы, а также библиотеки параметризируемых мегафункций, содержащих реализации типовых структур ЦФ.

Фирма ALTERA предоставляет в составе Altera DSP Design KIT програмный продукт Firgen. В функции программы Firgen входит моделирование КИХ-фильтра с заданными коэффициентами, а также генерация файлов, предназначенных для реализации фильтра штатными средствами пакета MAX+Plus II. Для построения отклика фильтра, полученного в результате моделирования средствами Firgen можно использовать либо пакет Microsoft Exel, либо входящий в состав Altera DSP Design KIT продукт GNUplot. Схематически процесс разработки фильтра представлен на рис 5.3.

В таблице 5.2. сведены данные о мегафункциях фильтров, входящих в состав Altera DSP Design KIT.

Непосредственная реализация цифровых полиномиальных фильтров связана с вычислением произведения векторов. Вычислительные затраты могут быть сокращены за счет использования свойства симметрии изотропных фильтров

Рис. 5.4. Систолическая реализация двухмерной линейной свертки

Для выполнения многомерной свертки требуется единственная модификация базовой ячейки с двумя потоками - добавление требуемого числа систолических входных потоков и соответствующее увеличение размера мультиплексора для выбора данных.

При решении задач фильтрации изображения с целью удаления шумов, восстановления изображения или улучшения его качества приходится иметь дело с данными имеющими широкий динамический диапазон. Поэтому в качестве формата данных необходимо использовать числа с плавающей запятой.

На рис 5.5 приведена реализация структуры на ПЛИС, а на рис 5.6 результаты моделирования систолической структуры в среде MAX PLUS II.

Рис 5.5. Реализация систолической структуры на ПЛИС

Рис 5.6 Результаты моделирования систолической структуры на ПЛИС.

Включение сдвиговых регистров на выходах промежуточных сумматоров позволяет обеспечить конвейеризацию обработки данных и, следовательно, повысить производительность. При этом регистры входят в состав соответствующих ЛЭ, поэтому сохраняется компактность структуры, не требуется задействовать дополнительные ЛЭ.

При реализации операции умножения на константу и возведения в степень целесообразно использовать конструкцию TABLE языка AHDL, как показывает сравнение, такое построение позволяет обеспечить более компактную и быстродействующую реализацию. Ниже приводится пример такой конструкции

TABLE

net[11..1] => out[15..1];

B"0000000XXXX" => B"000000000000000";

B"00000100000" => B"000001010111010";

.

.B"11111110000" => B"010011100001101";

B"00000010001" => B"010011100001110";

End TABLE;

При реализации перемножителей как правило используются матричные структуры, построенные каскадированием битовых сумматоров.

Обобщенная структурная схема, по которой реализован демодулятор сигналов с частотной манипуляцией, приведена на рис.5.7.

рис. 5.7.

Ниже приводится описание конструкций каждого из блоков в составе ПЛИС: детектора ЧМн - сигнала и синхронизатора. Определены преимущества каждой из предлагаемых схем.

.

Отсюда вытекает структурная схема детектора, которая приведена на рис.5.8.

Рис. 5.8.

Следует отметить преимущества предлагаемого алгоритма демодуляции ЧМн - сигнала:

Рис.5.9.

К преимуществам предлагаемого алгоритма следует отнести:

Реализованный восьмиотводный фильтр имеет симметричную характеристику.

Сигналы с выходов фильтров (восемь бит в дополнительном коде) подаются на квадратурные входы блока частотной демодуляции.

Входным сигналом синхронизатора является выход блока демодулятора.

Заметим, что для реализации суммирования вида

Рис. 5.10

Генератор формирования М-последовательностей был написан в виде параметризованной макрофункции, описывающей устройство, упрощенная структура которого показана на рис.5.11. Параметрами макрофункции являются длина характеристического многочлена и число, описывающее начальные состояния триггеров.

Рис.5.11

Функция M_GENERATE:

%===============================================%

% Генерирует М-последовательность, заданную %

% %

% Выходы: %

% OUT - выход М-последовательности %

% %

% Параметры: %

% M_WIDTH - длина полинома; %

% M_BEGIN - начальное состояние %

% (default="100000..00"); %

% %

%===============================================%

INCLUDE "lpm_xor.inc";

INCLUDE "lpm_constant.inc";

PARAMETERS

(

M_WIDTH,

M_BEGIN = 0

);

SUBDESIGN m_generate

(

M[M_WIDTH-1..0] : INPUT = GND;

CLK : INPUT;

GENA : INPUT = GND;

LOAD : INPUT = GND;

OUT : OUTPUT;

)

VARIABLE

dffs[M_WIDTH-2..0] : DFFE; -- триггеры регистра сдвига

shift_node[M_WIDTH-2..0] : NODE;

xor_node[M_WIDTH-2..0] : NODE;

shiftin, shiftout : NODE; -- вход и выход регистра сдвига

IF (USED(M_BEGIN)) GENERATE

ac : lpm_constant

WITH (LPM_WIDTH = M_WIDTH, LPM_CVALUE = M_BEGIN);

END GENERATE;

BEGIN

ASSERT (M_WIDTH>0)

REPORT "Значение параметра M_WIDTH должно быть больше нуля"

SEVERITY ERROR;

dffs[].ena = GENA;

dffs[].clk = CLK;

IF (USED(M_BEGIN)) GENERATE

ELSE GENERATE

END GENERATE;

xor_node[] = dffs[] & M[M_WIDTH-2..0];

shiftin = lpm_xor(xor_node[])

WITH (LPM_SIZE = M_WIDTH-1, LPM_WIDTH=1);

shift_node[] = (shiftin, dffs[M_WIDTH-2..1]);

shiftout = dffs[0];

dffs[].d = !load & shift_node[];

OUT = shiftout;

END;

Входы:

Выходы:

FUNCTION m_generate (m[(m_width) - (1)..0], clk, gena, load)

WITH (M_WIDTH, M_BEGIN)

RETURNS (out);

Рис.5.12.

Рис.5.13.

Рис.5.14.

library ieee;

use ieee.std_logic_1164.all;

entity Serial is

port (

clk : in STD_LOGIC;

load : in STD_LOGIC;

reset: in STD_LOGIC;

d : in STD_LOGIC_vector (3 downto 0);

oclk : out STD_LOGIC;

o : out STD_LOGIC;

e : out STD_LOGIC

);

end;

architecture behavioral of Serial is

type t1 is range 0 to 4;

signal s : STD_LOGIC_vector (2 downto 0);

signal i : t1;

begin

process (clk)

begin

if reset = '1' then

i <= 0;

else

if (clk'event and clk='1') then

if (i = 0 and load = '1') then

s(2 downto 0) <= d(3 downto 1);

o <= d(0);

i <= 4;

end if;

if (i > 1) then

o <= s(0);

s(1 downto 0) <= s(2 downto 1);

i <= i - 1;

end if;

if (i = 1) then

e <= '1';

i <= 0;

else

e <= '0';

end if;

end if;

end if;

if i>0 then

oclk <= not clk;

else

oclk <= '0';

end if;

end process;

end behavioral;

По переднему фронту синхроимпульса 'clk' при высоком уровне на входе загрузки происходит загрузка трех старших бит входного слова d[3..1] во временный регистр s[2..0]. Младший бит входного слова d[0] подается на выход 'o'. На выходе 'oclk' появляются синхроимпульсы. На сигнале 'i' собран внутренний счетчик, выдающий сигнал окончания преобразования 'e'. При поступлении последующих синхроимпульсов происходит выдача на выход 'o' остальных бит входного слова, хранящихся в регистре s[2..0].

Моделирование этого устройства было проведено в системе проектирования OrCAD 9.0

Для тестирования схемы использовался тест:

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

entity test_serial is end test_serial;

architecture testbench of test_serial is

component serial

port (

clk : in std_logic;

load : in std_logic;

reset : in std_logic;

d : in std_logic_vector(3 downto 0);

oclk : out std_logic;

o : out std_logic;

e : out std_logic

);

end component;

signal clk : std_logic;

signal load : std_logic := '0';

signal reset : std_logic;

signal d : std_logic_vector(3 downto 0);

signal oclk : std_logic;

signal o : std_logic;

signal e : std_logic;

begin

process begin

for i in 0 to 50 loop

clk <= '0'; wait for 5 ns;

clk <= '1'; wait for 5 ns;

end loop;

end process;

process begin

reset <= '1'; wait for 10 ns;

reset <= '0' ;

load <= '1';

d <= "1010"; wait for 10 ns;

load <= '0';

d <= "0000"; wait for 500 ns;

end process;

dut : serial port map (

clk => clk,

load => load,

reset => reset,

d => d,

oclk => oclk,

o => o,

e => e

);

end testbench;

Рис.5.15

y_n=A₀x_n + A₁x_n-1 + A₂x_n-2 + :,

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_arith.all;

entity f is

port (

din: in std_logic_vector(7 downto 0);

sout: out std_logic_vector(15 downto 0);

r: in std_logic;

c: in std_logic

);

end f;

architecture behavior of f is

constant h00 : std_logic_vector(7 downto 0) := "00000000";

constant h01 : std_logic_vector(7 downto 0) := "00000001";

constant h02 : std_logic_vector(7 downto 0) := "00000100";

constant h03 : std_logic_vector(7 downto 0) := "00001111";

constant h04 : std_logic_vector(7 downto 0) := "00100100";

constant h05 : std_logic_vector(7 downto 0) := "01000010";

constant h06 : std_logic_vector(7 downto 0) := "01100100";

constant h07 : std_logic_vector(7 downto 0) := "01111100";

constant h08 : std_logic_vector(7 downto 0) := "01111111";

constant h09 : std_logic_vector(7 downto 0) := "01101010";

constant h10 : std_logic_vector(7 downto 0) := "01000010";

constant h11 : std_logic_vector(7 downto 0) := "00010011";

constant h12 : std_logic_vector(7 downto 0) := "11101100";

constant h13 : std_logic_vector(7 downto 0) := "11010110";

constant h14 : std_logic_vector(7 downto 0) := "11010101";

constant h15 : std_logic_vector(7 downto 0) := "11100011";

constant h16 : std_logic_vector(7 downto 0) := "11110111";

constant h17 : std_logic_vector(7 downto 0) := "00001010";

constant h18 : std_logic_vector(7 downto 0) := "00010100";

constant h19 : std_logic_vector(7 downto 0) := "00010011";

constant h20 : std_logic_vector(7 downto 0) := "00001100";

constant h21 : std_logic_vector(7 downto 0) := "00000010";

constant h22 : std_logic_vector(7 downto 0) := "11111000";

constant h23 : std_logic_vector(7 downto 0) := "11110101";

signal x00, x01, x02, x03, x04, x05, x06, x07,

x08, x09, x10, x11, x12, x13, x14, x15,

x16, x17, x18, x19, x20, x21,

x22, x23 : std_logic_vector(7 downto 0);

signal m00, m01, m02, m03, m04, m05, m06, m07,

m08, m09, m10, m11, m12, m13, m14, m15,

m16, m17, m18, m19, m20, m21,

m22, m23 : std_logic_vector(15 downto 0);

begin

m00 <= (signed(x00)*signed(h00));

m01 <= (signed(x01)*signed(h01));

m02 <= (signed(x02)*signed(h02));

m03 <= (signed(x03)*signed(h03));

m04 <= (signed(x04)*signed(h04));

m05 <= (signed(x05)*signed(h05));

m06 <= (signed(x06)*signed(h06));

m07 <= (signed(x07)*signed(h07));

m08 <= (signed(x08)*signed(h08));

m09 <= (signed(x09)*signed(h09));

m10 <= (signed(x10)*signed(h10));

m11 <= (signed(x11)*signed(h11));

m12 <= (signed(x12)*signed(h12));

m13 <= (signed(x13)*signed(h13));

m14 <= (signed(x14)*signed(h14));

m15 <= (signed(x15)*signed(h15));

m16 <= (signed(x16)*signed(h16));

m17 <= (signed(x17)*signed(h17));

m18 <= (signed(x18)*signed(h18));

m19 <= (signed(x19)*signed(h19));

m20 <= (signed(x20)*signed(h20));

m21 <= (signed(x21)*signed(h21));

m22 <= (signed(x22)*signed(h22));

m23 <= (signed(x23)*signed(h23));

sout <= (signed(m00)+signed(m01)+signed(m02)+signed(m03)

+signed(m04)+signed(m05)+signed(m06)+signed(m07)

+signed(m08)+signed(m09)+signed(m10)+signed(m11)

+signed(m12)+signed(m13)+signed(m14)+signed(m15)

+signed(m16)+signed(m17)+signed(m18)+signed(m19)

+signed(m20)+signed(m21)+signed(m22)+signed(m23));

process(c,r)

begin

if r='1' then

x00 <= (others => '0');

x01 <= (others => '0');

x02 <= (others => '0');

x03 <= (others => '0');

x04 <= (others => '0');

x05 <= (others => '0');

x06 <= (others => '0');

x07 <= (others => '0');

x08 <= (others => '0');

x09 <= (others => '0');

x10 <= (others => '0');

x11 <= (others => '0');

x12 <= (others => '0');

x13 <= (others => '0');

x14 <= (others => '0');

x15 <= (others => '0');

x16 <= (others => '0');

x17 <= (others => '0');

x18 <= (others => '0');

x19 <= (others => '0');

x20 <= (others => '0');

x21 <= (others => '0');

x22 <= (others => '0');

x23 <= (others => '0');

elsif (c'event and c='1') then

x00(7 downto 0) <= din(7 downto 0);

x01(7 downto 0) <= x00(7 downto 0);

x02(7 downto 0) <= x01(7 downto 0);

x03(7 downto 0) <= x02(7 downto 0);

x04(7 downto 0) <= x03(7 downto 0);

x05(7 downto 0) <= x04(7 downto 0);

x06(7 downto 0) <= x05(7 downto 0);

x07(7 downto 0) <= x06(7 downto 0);

x08(7 downto 0) <= x07(7 downto 0);

x09(7 downto 0) <= x08(7 downto 0);

x10(7 downto 0) <= x09(7 downto 0);

x11(7 downto 0) <= x10(7 downto 0);

x12(7 downto 0) <= x11(7 downto 0);

x13(7 downto 0) <= x12(7 downto 0);

x14(7 downto 0) <= x13(7 downto 0);

x15(7 downto 0) <= x14(7 downto 0);

x16(7 downto 0) <= x15(7 downto 0);

x17(7 downto 0) <= x16(7 downto 0);

x18(7 downto 0) <= x17(7 downto 0);

x19(7 downto 0) <= x18(7 downto 0);

x20(7 downto 0) <= x19(7 downto 0);

x21(7 downto 0) <= x20(7 downto 0);

x22(7 downto 0) <= x21(7 downto 0);

x23(7 downto 0) <= x22(7 downto 0);

end if;

end process;

end behavior;

Входные данные считываются с входа din[7..0] в дополнительном коде по переднему фронту синхросигнала 'c'

На сигналах x0 ¸ x23 построен сдвиговый регистр, обеспечивающий задержку данных на 24 такта. Сигналы с регистров умножаются на весовые коэффициенты h0 ¸ h23 и суммируются.

Для тестирования схемы использован тест:

-- Test bench shell

library ieee;

use ieee.std_logic_1164.all;

entity test_f is end test_f;

architecture testbench of test_f is

component f

port (

din : in std_logic_vector(7 downto 0);

sout : out std_logic_vector(15 downto 0);

r : in std_logic;

c : in std_logic

);

end component;

signal din : std_logic_vector(7 downto 0);

signal sout : std_logic_vector(15 downto 0);

signal r : std_logic;

signal c : std_logic;

begin

process begin

for i in 0 to 50 loop

c <= '0'; wait for 5 ns;

c <= '1'; wait for 5 ns;

end loop;

end process;

process begin

r <= '1'; wait for 10 ns;

r <= '0' ;

din <= "00000001"; wait for 10 ns;

din <= "00000000"; wait for 500 ns;

end process;

dut : f port map (

din => din,

sout => sout,

r => r,

c => c

);

end testbench;

Тест моделирует подачу на цифровой фильтр аналога d -функции. На выходе фильтра - его импульсная характеристика.

Результаты моделирования представлены на рис.5.16

Рис.5.16.

Рассмотрим реализацию на языке описания аппаратуры структуры трехвходового (количество входов легко варьируется) нейрона с логистической функцией активации (также может варьироваться). Весовые коэффициенты являются переменными, задаваемыми пользователем. Входные величины (как входы, так и веса) представлены шестнадцати разрядным кодом:

.

При обработке данных шестнадцатиразрядный код преобразуется к двенадцати - разрядному коду вида

.

Эта операция снижает точность, но обеспечивает обработку данных, имеющих более широкий динамический диапазон

Действия производятся только с целыми числами. Значения весов и входов преобразуем к целому числу и округляем, например число -7.2341 может быть представлено числом -72341. В этом случае во всех остальных значениях входов и весов запятая должна быть передвинута на 4 знака вправо (для десятичного числа).

Модель нейрона описывается в виде основного тела программы, к которому подключается набор процедур, выполняющих основные действия. Соответствующие распечатки текстов находятся в пункте ПРИЛОЖЕНИЯ.

Рассмотрим назначение подключаемых процедур:

FUNCTION mult_nrn (xx[7..0], yy[7..0], a[6..0], b[6..0], clk) RETURNS (p[14..0]);

FUNCTION sum8 (a[7..0], b[7..0], clk, cin) RETURNS (sum[7..0], crr);

FUNCTION norm8 (a[16..1]) RETURNS (s[12..1]);

FUNCTION sum4 (a[3..0], b[3..0], clk, cin) RETURNS (sum[3..0]);

FUNCTION norm_sum (a[12..1], b[12..1], clk) RETURNS (as[12..1], bs[12..1]);

FUNCTION dop_kod (xx[7..0], clk) RETURNS (yy[7..0]);

FUNCTION perep (clk, xxa[11..6], xxb[4..1]) RETURNS (yy[11..1]);

FUNCTION sigm (net[12..1]) RETURNS (out[16..1]); .

Приведем функции используемые в подпрограммах:

FUNCTION mult16b (xx, yy, a, b) RETURNS (s, c);

FUNCTION dop_kod1 (xx[3..0], clk) RETURNS (yy[3..0]); .

FUNCTION mult_nrn (xx[7..0], yy[7..0], a[6..0], b[6..0], clk) RETURNS (p[14..0]);

FUNCTION sum8 (a[7..0], b[7..0], clk, cin) RETURNS (sum[7..0], crr);

FUNCTION norm8 (a[16..1]) RETURNS (s[12..1]);

FUNCTION sum4 (a[3..0], b[3..0], clk, cin) RETURNS (sum[3..0]);

FUNCTION norm_sum (a[12..1], b[12..1], clk) RETURNS (as[12..1], bs[12..1]);

FUNCTION dop_kod (xx[7..0], clk) RETURNS (yy[7..0]);

FUNCTION perep (clk, xxa[11..6], xxb[4..1]) RETURNS (yy[11..1]);

FUNCTION sigm (net[12..1]) RETURNS (out[16..1]);

SUBDESIGN neiron_

%Последние биты в процедурах умножения во входных переменных и в ответе являются знаковыми%

%Реализуется трехвходовый однослойный нейрон %

(

clk:INPUT;

%n[3..0]:INPUT;%%Число входов нейрона 2-10%

w[16..1]:INPUT;%Веса%

ww[16..1]:INPUT;

www[16..1]:INPUT;

x_[16..1]:INPUT;%Входы%

xx[16..1]:INPUT;

xxx[16..1]:INPUT;

z[12..1]:OUTPUT;%Выход%

zz[16..1]:OUTPUT;

%Тестовые выходы%

o[12..1]:OUTPUT;%Умножение%

oo[12..1]:OUTPUT;

ooo[12..1]:OUTPUT;

jas[12..1]:OUTPUT;%Выравнивание перед сложением%

jbs[12..1]:OUTPUT;

jjas[12..1]:OUTPUT;

jjbs[12..1]:OUTPUT;

f[12..1]:OUTPUT;%Проверка суммы%

f_[11..5]:OUTPUT; %Проверка суммы (без переноса)%

ka[12..5]:OUTPUT;%Переменные для проверки работы с доп. кодом и вычитания с ним%

kb[11..5]:OUTPUT;

kabs[12..5]:OUTPUT;

)

VARIABLE

rx[3..1]:norm8;%Переменные нормализации входов%

rw[3..1]:norm8;%Переменные нормализации весов%

rs[3..1]:norm8;%Переменные нормализации промежуточных результатов%

s:mult_nrn;%Переменные умножения%

ss:mult_nrn;

sss:mult_nrn;

e[3..1]:sum4;%Переменные сложения показателей при умножении%

ee[3..1]:sum4;

q[2..1]:sum8;%Переменные сложения%

%qq:sum8;%

m[12..1]:NODE;%Вспомогательные переменные суммирования%

mm[12..1]:NODE;

t[2..1]:norm_sum;%Переменные приведения к одному показателю перед сложением%

p[2..1]:perep;%Переменная, переносящая переполнение разрядной сетки в показатель%

sg:sigm;%Переменная сигмоиды%

BEGIN

%Нормализация входов%

rx[1].a[16..1]=x_[16..1];

rx[2].a[16..1]=xx[16..1];

rx[3].a[16..1]=xxx[16..1];

%Нормализация весов%

rw[1].a[16..1]=w[16..1];

rw[2].a[16..1]=ww[16..1];

rw[3].a[16..1]=www[16..1];

%---------------------%

%Умножение входов на веса%

% знак числа|значение числа |показатель степени двойки - сдвиг%

%Числа перемножаются, показатели складываются%

s.xx[7..0]=rx[1].s[12..5];

s.yy[7..0]=rw[1].s[12..5];

s.a[6..0]=GND;

s.b[6..0]=GND;

s.clk=clk;

e[1].a[3..0]=rx[1].s[4..1];

e[1].b[3..0]=rw[1].s[4..1];

e[1].clk=clk;

e[1].cin=GND;

%Проводим нормализацию промежуточных результатов%

rs[1].a[16]=s.p[14]; %Знак%

rs[1].a[15]=GND;

rs[1].a[14..1]=s.p[13..0];

%Добавление показателя после нормализации%

ee[1].a[3..0]=e[1].sum[3..0];

ee[1].b[3..0]=rs[1].s[4..1];

ee[1].clk=clk;

ee[1].cin=GND;

%---------------------%

ss.xx[7..0]=rx[2].s[12..5];

ss.yy[7..0]=rw[2].s[12..5];

ss.a[6..0]=GND;

ss.b[6..0]=GND;

ss.clk=clk;

e[2].a[3..0]=rx[2].s[4..1];

e[2].b[3..0]=rw[2].s[4..1];

e[2].clk=clk;

e[2].cin=GND;

%Проводим нормализацию промежуточных результатов%

rs[2].a[16]=ss.p[14]; %Знак%

rs[2].a[15]=GND;

rs[2].a[14..1]=ss.p[13..0];

%Добавление показателя после нормализации%

ee[2].a[3..0]=e[2].sum[3..0];

ee[2].b[3..0]=rs[2].s[4..1];

ee[2].clk=clk;

ee[2].cin=GND;

%---------------------%

sss.xx[7..0]=rx[3].s[12..5];

sss.yy[7..0]=rw[3].s[12..5];

sss.a[6..0]=GND;

sss.b[6..0]=GND;

sss.clk=clk;

e[3].a[3..0]=rx[3].s[4..1];

e[3].b[3..0]=rw[3].s[4..1];

e[3].clk=clk;

e[3].cin=GND;

%Проводим нормализацию промежуточных результатов%

rs[3].a[16]=sss.p[14]; %Знак%

rs[3].a[15]=GND;

rs[3].a[14..1]=sss.p[13..0];

%Добавление показателя после нормализации%

ee[3].a[3..0]=e[3].sum[3..0];

ee[3].b[3..0]=rs[3].s[4..1];

ee[3].clk=clk;

ee[3].cin=GND;

%---------------------%

%тест%

%демонстрируют правильность выполнения умножения входов на веса и нормализации%

o[12..5]=rs[1].s[12..5]; o[4..1]=ee[1].sum[3..0];

oo[12..5]=rs[2].s[12..5]; oo[4..1]=ee[2].sum[3..0];

ooo[12..5]=rs[3].s[12..5]; ooo[4..1]=ee[3].sum[3..0];

%---------------------%

%Общий сумматор%

%во всех 3 случаях 14 бит - знаковый%

%Для корректного сложения необходимо равенство показательных частей. Приводим показательные

часть двух слагаемых к показательной части старшго из них.%

%Производим выравнивание по показательным частям%

t[1].a[12..5]=rs[1].s[12..5]; t[1].a[4..1]=ee[1].sum[3..0];

t[1].b[12..5]=rs[2].s[12..5]; t[1].b[4..1]=ee[2].sum[3..0];

t[1].clk=clk;

%---------------------%

%тест%

%демонстрируют правильность выполнения выравнивания значений перед сложением%

jas[12..1]=t[1].as[12..1];

jbs[12..1]=t[1].bs[12..1];

%---------------------%

%Произведем проверку знака (0 соответствует (-) и доп. коду) и запрос к дополнительному коду%

%Перевод необходим лишь при различных знаках%

If ((t[1].as[12]==GND)&(t[1].bs[12]==VCC))==VCC then

d[1].clk=clk;

d[1].xx[7]=GND; d[1].xx[6..0]=t[1].as[11..5];

%---------------------%

%тест%

ka[12..5]=t[1].bs[12..5];

kb[11..5]=d[1].yy[6..0];

%---------------------%

%Суммируем%

q[1].clk=clk;

q[1].cin=GND;

q[1].a[7..0]=t[1].bs[12..5];

q[1].b[7]=GND; q[1].b[6..0]=d[1].yy[6..0];

%---------------------%

%тест%

kabs[12..5]=q[1].sum[7..0];

%---------------------%

%Проверка на получение отрицательного результата в доп. коде%

%If (q[1].sum[7]==GND) then???% %То перевод из доп. кода и постановка знака - (0)%

If (q[1].sum[7]==VCC) then

d[2].clk=clk;

d[2].xx[7]=GND; d[2].xx[6..0]=q[1].sum[6..0];

m[12]=GND; m[11..5]=d[2].yy[6..0];

Else

m[12]=VCC;m[11..5]=q[1].sum[6..0];

End If;

m[4..1]=t[1].as[4..1];%Показательная часть при вычитании не изменяется. М.б. t[1].bs[4..1]%

%Перевод необходим лишь при различных знаках%

ElsIf ((t[1].as[12]==VCC)&(t[1].bs[12]==GND))==VCC then

d[1].clk=clk;

d[1].xx[7]=GND; d[1].xx[6..0]=t[1].bs[11..5];

%---------------------%

%тест%

ka[12..5]=t[1].as[12..5];

kb[11..5]=d[1].yy[6..0];

%---------------------%

%Суммируем%

q[1].clk=clk;

q[1].cin=GND;

q[1].a[7..0]=t[1].as[12..5];

q[1].b[7]=GND; q[1].b[6..0]=d[1].yy[6..0];

%---------------------%

%тест%

kabs[12..5]=q[1].sum[7..0];

%---------------------%

%Проверка на получение отрицательного результата в доп. коде%

%If (q[1].sum[7]==GND) then???% %То перевод из доп. кода и постановка знака - (0)%

If (q[1].sum[7]==VCC) then

d[2].clk=clk;

d[2].xx[7]=GND; d[2].xx[6..0]=q[1].sum[6..0];

m[12]=GND; m[11..5]=d[2].yy[6..0];

Else

m[12]=VCC;m[11..5]=q[1].sum[6..0];

End If;

Else %В случае двух положительных или двух отрицательных слагаемых%

%Суммируем%

q[1].clk=clk;

q[1].cin=GND;

q[1].a[6..0]=t[1].bs[11..5];%Восьмой бит - знаковый%

q[1].b[6..0]=t[1].as[11..5];

%---------------------%

%тест%

%демонстрируют правильность выполнения сложения (без переносов)%

f_[11..5]=q[1].sum[6..0];

%---------------------%

%Проверка на переполнение разрядной сетки уместна лишь при сложении чисел одного знака%

If (q[1].sum[7]==VCC) then

p[1].clk=clk;

p[1].xxa[11..6]=q[1].sum[6..1];

p[1].xxb[4..1]=t[1].bs[4..1];%можно и t[1].as[4..1]%

m[12]=t[1].bs[12];%можно и t[1].as[12] - их знак одинаков%

m[11..1]=p[1].yy[11..1];

Else

m[12]=t[1].bs[12];%можно и t[1].as[12] - их знак одинаков%

m[11..5]=q[1].sum[6..0];

m[4..1]=t[1].bs[4..1];%можно и t[1].as[4..1]%

End If;

End If;

%---------------------%

%тест%

%демонстрируют правильность выполнения сложения%

f[12..1]=m[12..1];

%---------------------%

%---------------------%

%Производим выравнивание по показательным частям%

t[2].a[12..5]=m[12..5]; t[2].a[4..1]=m[4..1];

t[2].b[12..5]=rs[3].s[12..5]; t[2].b[4..1]=ee[3].sum[3..0];

t[2].clk=clk;

%---------------------%

%тест%

%демонстрируют правильность выполнения выравнивания значений перед сложением%

jjas[12..1]=t[2].as[12..1];

jjbs[12..1]=t[2].bs[12..1];

%---------------------%

%Произведем проверку знака (0 соответствует (-) и доп. коду) и запрос к дополнительному коду%

%Перевод необходим лишь при различных знаках%

If ((t[2].as[12]==GND)&(t[2].bs[12]==VCC))==VCC then

d[3].clk=clk;

d[3].xx[7]=GND; d[3].xx[6..0]=t[2].as[11..5];

%Суммируем%

q[2].clk=clk;

q[2].cin=GND;

q[2].a[7..0]=t[2].bs[12..5];

q[2].b[7]=GND; q[2].b[6..0]=d[3].yy[6..0];

%Проверка на получение отрицательного результата в доп. коде%

%If (q[2].sum[7]==GND) then???% %То перевод из доп. кода и постановка знака - (0)%

If (q[2].sum[7]==VCC) then

d[4].clk=clk;

d[4].xx[7]=GND; d[4].xx[6..0]=q[2].sum[6..0];

mm[12]=GND; mm[11..5]=d[4].yy[6..0];

Else

mm[12]=VCC; mm[11..5]=q[2].sum[6..0];

End If;

mm[4..1]=t[2].as[4..1];%Показательная часть при вычитании не изменяется. М.б. t[2].bs[4..1]%

%Перевод необходим лишь при различных знаках%

ElsIf ((t[2].as[12]==VCC)&(t[2].bs[12]==GND))==VCC then

d[3].clk=clk;

d[3].xx[7]=GND; d[3].xx[6..0]=t[2].bs[11..5];

%Суммируем%

q[2].clk=clk;

q[2].cin=GND;

q[2].a[7..0]=t[2].as[12..5];

q[2].b[7]=GND; q[2].b[6..0]=d[3].yy[6..0];

%Проверка на получение отрицательного результата в доп. коде%

If (q[2].sum[7]==VCC) then

d[4].clk=clk;

d[4].xx[7]=GND; d[4].xx[6..0]=q[2].sum[6..0];

mm[12]=GND; mm[11..5]=d[4].yy[6..0];

Else

mm[12]=VCC; mm[11..5]=q[2].sum[6..0];

End If;

mm[4..1]=t[2].as[4..1];%Показательная часть при вычитании не изменяется. М.б. t[2].bs[4..1]%

Else %В случае двух положительных или двух отрицательных слагаемых%

%Суммируем%

q[2].clk=clk;

q[2].cin=GND;

q[2].a[6..0]=t[2].bs[11..5];%Восьмой бит - знаковый%

q[2].b[6..0]=t[2].as[11..5];

%Проверка на переполнение разрядной сетки уместна лишь при сложении чисел одного знака%

If (q[2].sum[7]==VCC) then

p[2].clk=clk;

p[2].xxa[11..6]=q[2].sum[6..1];

mm[12]=t[2].bs[12];%можно и t[1].as[12] - их знак одинаков%

mm[11..1]=p[2].yy[11..1];

Else

mm[12]=t[2].bs[12];%можно и t[1].as[12] - их знак одинаков%

mm[11..5]=q[2].sum[6..0];

End If;

End If;

sg.net[12..1]=mm[12..1];

zz[16..1]=sg.out[16..1];

z[12..1]=mm[12..1];

END

Для операндов небольшой разрядности (4 и менее) наиболее результативна структура простого матричного суммирования (рис.5.17). Она реализует параллельный умножитель как массив одноразрядных сумматоров, соединенных локальными межсоединениями, при этом общее число сумматоров напрямую определяется разрядностью множимого и множителя.

Рис.5.17. Структура матричного умножителя с последовательным

распространением переноса

Так, полный параллельный умножитель 4´ 4 требует для своей реализации 12 сумматоров.. При дальнейшем наращивании разрядности матрица одноразрядных сумматоров значительно разрастается, одновременно увеличивается критический путь, и реализация умножителя становится нерациональной.

Одним из способов уменьшения аппаратных затрат служит использование алгоритма Бута. В соответствии с данным алгоритмом определенным образом анализируются парные биты множителя и в зависимости от их комбинации над множимым выполняются некоторые преобразования ( пример для умножителя 12´ 12 бит приведен в табл.5.3).

Как видно из таблицы, выполняемые над множимым действия отличаются для двух старших бит, один из которых знаковый. Подобная коррекция позволяет осуществлять операцию умножения над числами в дополнительном коде.

Сформированные частичные произведения, представляющие собой результат преобразования множимого, необходимо суммировать с соответствующим весовым фактором. Результатом их суммирования по алгоритму простого матричного умножителя и будет конечный продукт произведения двух операндов. Анализ различных методов свертки частичных произведений показал, что наиболее приемлемым для реализации на ПЛИС, является алгоритм на основе иерархического дерева многоразрядных масштабирующих сумматоров. При этом достигается сокращение аппаратных затрат по сравнению с параллельным матричным умножителем до двух раз.

Пример реализации данного решения для случая 12-разрядных операндов приведен на рисунке 5.18. В данной схеме выбор соответствующего преобразования множимого Y осуществляется мультиплексором на основании анализа парных бит множителя X в соответствии с табл.5.3. Входные значения мультиплексоров 0 и Y подаются непосредственно, значение 2Y формируется сдвигом множимого на один бит, а 3Y формируется путем сложения Y и 2Y

Сумматоры ADD осуществляют суммирование частичных произведений, причем их разрядность для разных ступеней иерархии неодинакова. На каждом шаге суммирования, как видно, имеются несколько сквозных бит, непосредственно дополняющих выходные значения сумматоров. За счет них и за счет битов расширения знака осуществляется необходимое масштабирование результата. Размерность произведения P в конечном итоге равна сумме размерностей операндов.

Рис.5.18. Структурная схема 12-разрядного умножителя на основе алгоритма Бута

За счет регулярности приведенной структуры быстродействие можно резко повысить путем введения конвейеризации каждой ступени. При этом разделяются конвейерными регистрами как сумматоры, так и мультиплексоры. Выигрыш в быстродействии благодаря данному решению оказывается особенно ощутимым для большой разрядности операндов.

Как видно из примера, используется каждая цифра множителя для поразрядного перемножения со всеми цифрами множимого и совсем необязательно знать всю таблицу произведений операндов полной разрядности. Для перемножения двух переменных достаточно иметь таблицу произведений множимого, в данном случае константы, на весь ранг возможных цифр множителя, и осуществить корректное суммирование полученных частичных произведений. Для случая 85´ 476 это иллюстрируется следующим образом:

Таблица произведений множимого записывается во фрагмент памяти на ПЛИС и называется таблицей перекодировок (ТП). ТП адресуются четырьмя разрядами, следовательно необходимо представить операнды в шестнадцатиричном коде, и массив ТП будет содержать таким образом массив произведений константы на ряд цифр 0, 1, ... , E, F:

Как видно из приведенного примера, для того чтобы осуществить операцию умножения двух двенадцатиразрядных двоичных чисел, одно из которых - константа, необходимо иметь ТП на 16 значений с разрядностью выходного значения 16 (для положительных чисел) и два 16-разрядных сумматора - рис. 5.19.

Рис.5.19. 12-разрядный умножитель на константу

Четыре младших бита выходного произведения нижней на рис.5.19 ТП непосредственно в соответствии с алгоритмом функционирования формируют четыре младших разряда окончательного произведения.

При подаче на сумматор указанного произведения необходимо произвести расширение знака в соответствии со значением старшего бита. Например, для 12-разрядных операндов:

Реализация по данному принципу операции умножения отрицательных чисел, представленных в дополнительном коде, не требует каких-либо изменений в технической реализации и не задействует дополнительную специальную логику коррекции; изменится лишь прошивка просмотровой таблицы, адресуемой знаковым битом входного операнда.