Ролята на FPGA.

R

richardyue

Guest
Здравейте, Потребители,
Имам един въпрос тук.Каква е ролята на FPGA в системата?Дано там ще бъде колкото е възможно членовете dicussing тази тема.Имам много въпроси, които са ме бърка много.Благодаря предварително.

 
Красотата на FPGA е, че може да се направи почти нищо цифрови.Ти го определят ролята.Един FPGA е изключително конфигурируеми.За разлика от ASICs, FPGA развитие е напълно възможно на пейката.Можете да си купите евтин развитие кит, инсталиране на софтуер, и да започнете да експериментирате веднага.Можете разработи алгоритми и приложения,
както и изпитването им на вашата малка дъска.Simple експерименти отнеме само няколко минути.

Давай напред и да ви много въпроси.Много хора тук са отговорите.Разбира се, моля те търсят в този форум (или Google) за общи отговори.

 
Уважаеми echo47,
Благодаря за помощта ви.Нека да направим нещата по специфични.Ако аз искам да се изработи система, която може да направи снимка обратни.Това е, ако снимки на точката в изображението е 0, то след тази система, снимки на точка ще бъде 1.Как да се приложи тази функционалност, като използвате FPGA?

 
richardyue написа:

Уважаеми echo47,

Благодаря за помощта ви.
Нека да направим нещата по специфични.
Ако аз искам да се изработи система, която може да направи снимка обратни.
Това е, ако снимки на точката в изображението е 0, то след тази система, снимки на точка ще бъде 1.
Как да се приложи тази функционалност, като използвате FPGA?
 
Чрез инверсия, мисля, че вие искате да конвертирате черно / бяло изображение в бяло / черно.Но "образ" е твърде неясно.Този проект може да бъде нещо от тривиалната (както е обяснено cfriend) до почти невъзможно (поддържа всички възможни изображение кодиране формат и входно / изходни метод).

 
FPGA са един от компонентите в hotests EA в този момент.

Ти направи всичко, паралелно какво искаш -> програмиране в VHDL, но тези дни FPGA имат меки или хардкор микропроцесори на борда, така че можете да инсталирате по повечето от тези микропроцесори OS
е като малък Linux, ..., където можете да пишете на софтуер.

Някои производители на FPGA се включат Аналогов блокове в техните FPGA (например http://www.Actel.com -> Fusion с ARM7 Core).

Така че един FPGA, може да бъде система, на самата ...

Ако искаш направи нещо в зрението / обработка на изображения можете да дадете на NI LabVIEW ВИЗИЯ пробвам: тук можете да програмирате една FPGA от употребата на NI LabVIEW и това е специален съвет за ВИЗИЯ приложения!

проверка:

http://www.ni.com/vision/cvs.htm

http://digital.ni.com/demo.nsf/websearch/4C78968C3518369E86256D82008322FD?OpenDocument&node=1286_US

 
Можем ли да кажем, че FPGA е процесор, точно като на процесора?Ако искате да създадете цифрова схема, например, като това, което са споменати, ние можем да разгледа FPGA като черната кутия.Ние се определят функциите на FPGA с помощта на софтуер, като например Xilinx ISE или Maxplus II.Прав ли съм?Съжалявам за моя глупав въпрос.

 
Вие можете да имате RISC microcontroller ядрото на FPGA като picoblaze
или мека сърцевина процесор като microblaze
те са както на xilinx FPGAs

 
Здрасти
Ролята на FPGA е
U дизайн нещо синтезира и симулира.тя работи добре, но тя не може да работи, когато ф изфабрикувам в чип.съществуват проблеми, свързани с хардуера зебло софтуер не могат да обработват.
така и не wan't да прекарат crores на рупии на маските изисква да изфабрикувам synthesised на RTL, а по-късно се покаят, ако тя не работи.
U пуснати в FPGA се провери това
е функционалност, а след това продължете.
и да спестите малко пари и да произвежда по-добри схеми

 
Един FPGA е като огромен цифров breadboard пълни с порти, флип-flops, овни, и други логически устройства.Можете да се помежду им почти никакъв начин, който искате, да се изгради почти всичко, което искаш.Може да се изгради собствен микропроцесор, или Ethernet контролер или видео Arcade игра, или банкова на цифрови филтри, или кодиране / разшифроването единица, или музикален синтезатор, или цифрова радио, или всички тези неща едновременно, .. .

Е, може би не всички тези неща едновременно, ако сте купили малка FPGA!

<img src="http://www.edaboard.com/images/smiles/icon_wink.gif" alt="Подрямване" border="0" />Последно редактирано от echo47 на 03 ноември 2006 13:33; редактирано 1 път общо

 
Здрасти ехо
Аз съм в изграждането на банката на цифрови филтри IIR bandpass на FPGA.всякакви предложения.

 
Един лесен начин за проектиране FIR и IIR филтри е да се използва MATLAB
на Filter Дизайн HDL Coder.Кликнете върху някои бутони, въведете вашето дизайн параметри, и то spits изложени готови за употреба VHDL или Verilog.
http://www.mathworks.com/access/helpdesk/help/toolbox/hdlfilter/

Все пак, ако искате да използвате едно парче логика да направя няколко работни места, като например компютърни няколко филтъра, вие вероятно
ще трябва да модифицирате MATLAB
на изхода.

Може също като Simulink HDL Coder.
http://www.mathworks.com/access/helpdesk/help/toolbox/slhdlcoder/

 
Знам, че основната вътрешна структура на FPGA.Тя се състои от I / O Блок, CLB и взаимно ресурс.В някои FPGA устройства, тя има Блок RAM.Защо имаме нужда от тази част?

 
скоро
Имам зебло използва за генериране на филтри.
Колко ефективни са тези кодове.
АЗ имам използван fdatool и филтърни дизайн HDL coder.
Мога ли да използвам това генерира еднократна филтър и развиват сериен архитектура чрез съхраняване на коефициентите в ROM, които са параметрите в verilog филтър код.

Отдавам отколкото на verilog код (съжалявам, че не знаят как да се направи огледален качване)

/ / ------------------------------------------------ -------------
/ /
/ / Модул: filter_bpf
/ /
/ / Генерирано от MATLAB (R) 7.0.4 и Filter Дизайн HDL Coder 1.2.
/ /
/ / Генерирани на: 2006-09-18 22:22:37
/ /
/ / BPF 850 1150 за 6
/ /
/ / ------------------------------------------------ -------------

/ / ------------------------------------------------ -------------
/ / HDL кодекс Генерация Опции:
/ /
/ / TargetLanguage: Verilog
/ / Име: filter_bpf
/ / UserComment: BPF 850 1150 за 6
/ / InlineConfigurations: Off
/ / SafeZeroConcat: Off
/ / CastBeforeSum: On// TestBenchName: filter_tb_bpf / / TestBenchStimulus: Стъпка рампата чуруликам
/ /
/ / Filter Настройки:
/ /
/ / Дискретни време IIR филтър (реални)
/ / -------------------------------
/ / Filter Структура: Директно-формуляр I, втори порядък Раздели
/ / Брой секции: 3
/ / Стабилна: Да
/ / Линейна Фаза: Не
/ / Аритметична: Твърда
/ / Числителят: s16, 14 -> [-2 2)
/ / Знаменател: s16, 14 -> [-2 2)
/ / Scale Стойности: s16, 14 -> [-2 2)
/ / Въвеждане: s16, 15 -> [-1 1)
/ / Изход: s16, 11 -> [-16 16)
/ / Числителят-членка: s16, 15 -> [-1 1)
/ / Знаменател-членка: s16, 15 -> [-1 1)
/ / Числителят Prod: s32, 29 -> [-4 4)
/ / Знаменател Prod: s32, 29 -> [-4 4)
/ / Числителят Accum: S40, 29 -> [-1024 1024)
/ / Знаменател Accum: S40, 29 -> [-1024 1024)
/ / Кръг Режим: етаж
/ / Overflow Режим: пропивам
/ / В ролите Преди сума: вярно
/ / ------------------------------------------------ -------------

"времева 1 NS / 1 NS

Модулът filter_bpf (clk, clk_enable, нулиране, filter_in, filter_out);

вход clk;
вход clk_enable;
въвеждане на промените;
вход подписано [15:0] filter_in; / / sfix16_En15
продукция подписано [15:0] filter_out; / / sfix16_En11

/ / Местни Функции
/ / Вид Дефиниции
/ / Константи
параметър подписано [15:0] scaleconst1 = 16'b0000000101011010; / / sfix16_En14
параметър подписано [15:0] coeff_b1_section1 = 16'b0100000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_b2_section1 = 16'b0000000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_b3_section1 = 16'b1100000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_a2_section1 = 16'b1000001100101000; / / sfix16_En14
параметър подписано [15:0] coeff_a3_section1 = 16'b0011111001111001; / / sfix16_En14
параметър подписано [15:0] scaleconst2 = 16'b0000000101011010; / / sfix16_En14
параметър подписано [15:0] coeff_b1_section2 = 16'b0100000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_b2_section2 = 16'b0000000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_b3_section2 = 16'b1100000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_a2_section2 = 16'b1000001000100101; / / sfix16_En14
параметър подписано [15:0] coeff_a3_section2 = 16'b0011111011010010; / / sfix16_En14
параметър подписано [15:0] scaleconst3 = 16'b0000000101010111; / / sfix16_En14
параметър подписано [15:0] coeff_b1_section3 = 16'b0100000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_b2_section3 = 16'b0000000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_b3_section3 = 16'b1100000000000000; / / sfix16_En14
параметър подписано [15:0] coeff_a2_section3 = 16'b1000001111101100; / / sfix16_En14
параметър подписано [15:0] coeff_a3_section3 = 16'b0011110101010010; / / sfix16_En14
/ / Сигнали
рег. подписано [15:0] input_register; / / sfix16_En15
телени подписано [15:0] scale1; / / sfix16_En15
телени подписано [31:0] mul_temp; / / sfix32_En29
/ / Раздел 1 Сигнали
телени подписано [39:0] a1sum1; / / sfix40_En29
телени подписано [39:0] a2sum1; / / sfix40_En29
телени подписано [39:0] b1sum1; / / sfix40_En29
телени подписано [39:0] b2sum1; / / sfix40_En29
телени подписано [15:0] numtypeconvert1; / / sfix16_En15
телени подписано [15:0] dentypeconvert1; / / sfix16_En15
рег. подписано [15:0] numdelay_section1 [0:1]; / / sfix16_En15
рег. подписано [15:0] dendelay_section1 [0:1]; / / sfix16_En15
телени подписано [31:0] a2mul1; / / sfix32_En29
телени подписано [31:0] a3mul1; / / sfix32_En29
телени подписано [31:0] b1mul1; / / sfix32_En29
телени подписано [31:0] b3mul1; / / sfix32_En29
телени подписано [16:0] unaryminus_temp; / / sfix17_En15
телени подписано [39:0] b1multypeconvert1; / / sfix40_En29
телени подписано [39:0] add_cast; / / sfix40_En29
телени подписано [39:0] add_cast_1; / / sfix40_En29
телени подписано [40:0] add_temp; / / sfix41_En29
телени подписано [39:0] sub_cast; / / sfix40_En29
телени подписано [39:0] sub_cast_1; / / sfix40_En29
телени подписано [40:0] sub_temp; / / sfix41_En29
телени подписано [39:0] sub_cast_2; / / sfix40_En29
телени подписано [39:0] sub_cast_3; / / sfix40_En29
телени подписано [40:0] sub_temp_1; / / sfix41_En29
телени подписано [15:0] scale2; / / sfix16_En15
телени подписано [31:0] mul_temp_1; / / sfix32_En29
/ / Раздел 2 Сигнали
телени подписано [39:0] a1sum2; / / sfix40_En29
телени подписано [39:0] a2sum2; / / sfix40_En29
телени подписано [39:0] b1sum2; / / sfix40_En29
телени подписано [39:0] b2sum2; / / sfix40_En29
телени подписано [15:0] numtypeconvert2; / / sfix16_En15
телени подписано [15:0] dentypeconvert2; / / sfix16_En15
рег. подписано [15:0] numdelay_section2 [0:1]; / / sfix16_En15
рег. подписано [15:0] dendelay_section2 [0:1]; / / sfix16_En15
телени подписано [31:0] a2mul2; / / sfix32_En29
телени подписано [31:0] a3mul2; / / sfix32_En29
телени подписано [31:0] b1mul2; / / sfix32_En29
телени подписано [31:0] b3mul2; / / sfix32_En29
телени подписано [16:0] unaryminus_temp_1; / / sfix17_En15
телени подписано [39:0] b1multypeconvert2; / / sfix40_En29
телени подписано [39:0] add_cast_2; / / sfix40_En29
телени подписано [39:0] add_cast_3; / / sfix40_En29
телени подписано [40:0] add_temp_1; / / sfix41_En29
телени подписано [39:0] sub_cast_4; / / sfix40_En29
телени подписано [39:0] sub_cast_5; / / sfix40_En29
телени подписано [40:0] sub_temp_2; / / sfix41_En29
телени подписано [39:0] sub_cast_6; / / sfix40_En29
телени подписано [39:0] sub_cast_7; / / sfix40_En29
телени подписано [40:0] sub_temp_3; / / sfix41_En29
телени подписано [15:0] scale3; / / sfix16_En15
телени подписано [31:0] mul_temp_2; / / sfix32_En29
/ / Раздел 3 Сигнали
телени подписано [39:0] a1sum3; / / sfix40_En29
телени подписано [39:0] a2sum3; / / sfix40_En29
телени подписано [39:0] b1sum3; / / sfix40_En29
телени подписано [39:0] b2sum3; / / sfix40_En29
телени подписано [15:0] numtypeconvert3; / / sfix16_En15
телени подписано [15:0] dentypeconvert3; / / sfix16_En15
рег. подписано [15:0] numdelay_section3 [0:1]; / / sfix16_En15
рег. подписано [15:0] dendelay_section3 [0:1]; / / sfix16_En15
телени подписано [31:0] a2mul3; / / sfix32_En29
телени подписано [31:0] a3mul3; / / sfix32_En29
телени подписано [31:0] b1mul3; / / sfix32_En29
телени подписано [31:0] b3mul3; / / sfix32_En29
телени подписано [16:0] unaryminus_temp_2; / / sfix17_En15
телени подписано [39:0] b1multypeconvert3; / / sfix40_En29
телени подписано [39:0] add_cast_4; / / sfix40_En29
телени подписано [39:0] add_cast_5; / / sfix40_En29
телени подписано [40:0] add_temp_2; / / sfix41_En29
телени подписано [39:0] sub_cast_8; / / sfix40_En29
телени подписано [39:0] sub_cast_9; / / sfix40_En29
телени подписано [40:0] sub_temp_4; / / sfix41_En29
телени подписано [39:0] sub_cast_10; / / sfix40_En29
телени подписано [39:0] sub_cast_11; / / sfix40_En29
телени подписано [40:0] sub_temp_5; / / sfix41_En29
телени подписано [15:0] output_typeconvert; / / sfix16_En11
рег. подписано [15:0] output_register; / / sfix16_En11

/ / Блок Изявления
Винаги @ (posedge clk или posedge нулиране)
започва: input_reg_process
ако (нулиране == 1'b1) започва
input_register <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
input_register <= filter_in;
приключвам
приключвам
край / / input_reg_process

присвоите mul_temp = input_register * scaleconst1;
присвоите scale1 = (mul_temp [31] == 1'b0 & mul_temp [30:29]! = 2'b00)?16'b0111111111111111:(mul_temp[31] == 1'b1 && mul_temp[30:29] != 2'b11) ?

16'b1000000000000000: mul_temp [29:14];

/ / ------------------ Раздел 1 ------------------

присвоите numtypeconvert1 = scale1;

присвоите dentypeconvert1 = (a1sum1 [39] == 1'b0 & a1sum1 [38:29]! = 10'b0000000000)?16'b0111111111111111:
(a1sum1 [39] == 1'b1 & & a1sum1 [38:29]! = 10'b1111111111)?16'b1000000000000000: a1sum1 [29:14];

Винаги @ (posedge clk или posedge нулиране)
започва: numdelay_process_section1
ако (нулиране == 1'b1) започва
numdelay_section1 [0] <= 0;
numdelay_section1 [1] <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
numdelay_section1 [0] <= numtypeconvert1;
numdelay_section1 [1] <= numdelay_section1 [0];
приключвам
приключвам
край / / numdelay_process_section1

Винаги @ (posedge clk или posedge нулиране)
започва: dendelay_process_section1
ако (нулиране == 1'b1) започва
dendelay_section1 [0] <= 0;
dendelay_section1 [1] <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
dendelay_section1 [0] <= dentypeconvert1;
dendelay_section1 [1] <= dendelay_section1 [0];
приключвам
приключвам
край / / dendelay_process_section1

присвоите a2mul1 = dendelay_section1 [0] * coeff_a2_section1;

присвоите a3mul1 = dendelay_section1 [1] * coeff_a3_section1;

присвоите b1mul1 = $ подписано ((numtypeconvert1, 14'b00000000000000));

присвоите unaryminus_temp = (numdelay_section1 [1] == 16'b1000000000000000)?$ подписано ((1'b0, numdelay_section1 [1])):-numdelay_section1 [1];
присвоите b3mul1 = $ подписано ((unaryminus_temp, 14'b00000000000000));

присвоите b1multypeconvert1 = $ подписано (8 (((b1mul1 [31])), b1mul1));

присвоите b1sum1 = b1multypeconvert1;

присвоите add_cast = b1sum1;
присвоите add_cast_1 = $ подписано (8 (((b3mul1 [31])), b3mul1));
присвоите add_temp = add_cast add_cast_1;
присвоите b2sum1 = (add_temp [40] == 1'b0 & add_temp [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(add_temp [40] == 1'b1 & & add_temp [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: add_temp [39:0];

присвоите sub_cast = b2sum1;
присвоите sub_cast_1 = $ подписано (8 (((a2mul1 [31])), a2mul1));
присвоите sub_temp = sub_cast - sub_cast_1;
присвоите a2sum1 = (sub_temp [40] == 1'b0 & sub_temp [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(sub_temp [40] == 1'b1 & & sub_temp [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: sub_temp [39:0];

присвоите sub_cast_2 = a2sum1;
присвоите sub_cast_3 = $ подписано (8 (((a3mul1 [31])), a3mul1));
присвоите sub_temp_1 = sub_cast_2 - sub_cast_3;
присвоите a1sum1 = (sub_temp_1 [40] == 1'b0 & sub_temp_1 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(sub_temp_1 [40] == 1'b1 & & sub_temp_1 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: sub_temp_1 [39:0];

присвоите mul_temp_1 = dentypeconvert1 * scaleconst2;
присвоите scale2 = (mul_temp_1 [31] == 1'b0 & mul_temp_1 [30:29]! = 2'b00)?16'b0111111111111111:
(mul_temp_1 [31] == 1'b1 & & mul_temp_1 [30:29]! = 2'b11)?16'b1000000000000000: mul_temp_1 [29:14];

/ / ------------------ Раздел 2 ------------------

присвоите numtypeconvert2 = scale2;

присвоите dentypeconvert2 = (a1sum2 [39] == 1'b0 & a1sum2 [38:29]! = 10'b0000000000)?16'b0111111111111111:
(a1sum2 [39] == 1'b1 & & a1sum2 [38:29]! = 10'b1111111111)?16'b1000000000000000: a1sum2 [29:14];

Винаги @ (posedge clk или posedge нулиране)
започва: numdelay_process_section2
ако (нулиране == 1'b1) започва
numdelay_section2 [0] <= 0;
numdelay_section2 [1] <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
numdelay_section2 [0] <= numtypeconvert2;
numdelay_section2 [1] <= numdelay_section2 [0];
приключвам
приключвам
край / / numdelay_process_section2

Винаги @ (posedge clk или posedge нулиране)
започва: dendelay_process_section2
ако (нулиране == 1'b1) започва
dendelay_section2 [0] <= 0;
dendelay_section2 [1] <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
dendelay_section2 [0] <= dentypeconvert2;
dendelay_section2 [1] <= dendelay_section2 [0];
приключвам
приключвам
край / / dendelay_process_section2

присвоите a2mul2 = dendelay_section2 [0] * coeff_a2_section2;

присвоите a3mul2 = dendelay_section2 [1] * coeff_a3_section2;

присвоите b1mul2 = $ подписано ((numtypeconvert2, 14'b00000000000000));

присвоите unaryminus_temp_1 = (numdelay_section2 [1] == 16'b1000000000000000)?$ подписано ((1'b0, numdelay_section2 [1])):-numdelay_section2 [1];
присвоите b3mul2 = $ подписано ((unaryminus_temp_1, 14'b00000000000000));

присвоите b1multypeconvert2 = $ подписано (8 (((b1mul2 [31])), b1mul2));

присвоите b1sum2 = b1multypeconvert2;

присвоите add_cast_2 = b1sum2;
присвоите add_cast_3 = $ подписано (8 (((b3mul2 [31])), b3mul2));
присвоите add_temp_1 = add_cast_2 add_cast_3;
присвоите b2sum2 = (add_temp_1 [40] == 1'b0 & add_temp_1 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(add_temp_1 [40] == 1'b1 & & add_temp_1 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: add_temp_1 [39:0];

присвоите sub_cast_4 = b2sum2;
присвоите sub_cast_5 = $ подписано (8 (((a2mul2 [31])), a2mul2));
присвоите sub_temp_2 = sub_cast_4 - sub_cast_5;
присвоите a2sum2 = (sub_temp_2 [40] == 1'b0 & sub_temp_2 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(sub_temp_2 [40] == 1'b1 & & sub_temp_2 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: sub_temp_2 [39:0];

присвоите sub_cast_6 = a2sum2;
присвоите sub_cast_7 = $ подписано (8 (((a3mul2 [31])), a3mul2));
присвоите sub_temp_3 = sub_cast_6 - sub_cast_7;
присвоите a1sum2 = (sub_temp_3 [40] == 1'b0 & sub_temp_3 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(sub_temp_3 [40] == 1'b1 & & sub_temp_3 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: sub_temp_3 [39:0];

присвоите mul_temp_2 = dentypeconvert2 * scaleconst3;
присвоите scale3 = (mul_temp_2 [31] == 1'b0 & mul_temp_2 [30:29]! = 2'b00)?16'b0111111111111111:
(mul_temp_2 [31] == 1'b1 & & mul_temp_2 [30:29]! = 2'b11)?16'b1000000000000000: mul_temp_2 [29:14];

/ / ------------------ Раздел 3 ------------------

присвоите numtypeconvert3 = scale3;

присвоите dentypeconvert3 = (a1sum3 [39] == 1'b0 & a1sum3 [38:29]! = 10'b0000000000)?16'b0111111111111111:
(a1sum3 [39] == 1'b1 & & a1sum3 [38:29]! = 10'b1111111111)?16'b1000000000000000: a1sum3 [29:14];

Винаги @ (posedge clk или posedge нулиране)
започва: numdelay_process_section3
ако (нулиране == 1'b1) започва
numdelay_section3 [0] <= 0;
numdelay_section3 [1] <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
numdelay_section3 [0] <= numtypeconvert3;
numdelay_section3 [1] <= numdelay_section3 [0];
приключвам
приключвам
край / / numdelay_process_section3

Винаги @ (posedge clk или posedge нулиране)
започва: dendelay_process_section3
ако (нулиране == 1'b1) започва
dendelay_section3 [0] <= 0;
dendelay_section3 [1] <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
dendelay_section3 [0] <= dentypeconvert3;
dendelay_section3 [1] <= dendelay_section3 [0];
приключвам
приключвам
край / / dendelay_process_section3

присвоите a2mul3 = dendelay_section3 [0] * coeff_a2_section3;

присвоите a3mul3 = dendelay_section3 [1] * coeff_a3_section3;

присвоите b1mul3 = $ подписано ((numtypeconvert3, 14'b00000000000000));

присвоите unaryminus_temp_2 = (numdelay_section3 [1] == 16'b1000000000000000)?$ подписано ((1'b0, numdelay_section3 [1])):-numdelay_section3 [1];
присвоите b3mul3 = $ подписано ((unaryminus_temp_2, 14'b00000000000000));

присвоите b1multypeconvert3 = $ подписано (8 (((b1mul3 [31])), b1mul3));

присвоите b1sum3 = b1multypeconvert3;

присвоите add_cast_4 = b1sum3;
присвоите add_cast_5 = $ подписано (8 (((b3mul3 [31])), b3mul3));
присвоите add_temp_2 = add_cast_4 add_cast_5;
присвоите b2sum3 = (add_temp_2 [40] == 1'b0 & add_temp_2 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(add_temp_2 [40] == 1'b1 & & add_temp_2 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: add_temp_2 [39:0];

присвоите sub_cast_8 = b2sum3;
присвоите sub_cast_9 = $ подписано (8 (((a2mul3 [31])), a2mul3));
присвоите sub_temp_4 = sub_cast_8 - sub_cast_9;
присвоите a2sum3 = (sub_temp_4 [40] == 1'b0 & sub_temp_4 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(sub_temp_4 [40] == 1'b1 & & sub_temp_4 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: sub_temp_4 [39:0];

присвоите sub_cast_10 = a2sum3;
присвоите sub_cast_11 = $ подписано (8 (((a3mul3 [31])), a3mul3));
присвоите sub_temp_5 = sub_cast_10 - sub_cast_11;
присвоите a1sum3 = (sub_temp_5 [40] == 1'b0 & sub_temp_5 [39]! = 1'b0)?40'b0111111111111111111111111111111111111111:
(sub_temp_5 [40] == 1'b1 & & sub_temp_5 [39]! = 1'b1)?40'b1000000000000000000000000000000000000000: sub_temp_5 [39:0];

присвоите output_typeconvert = $ подписано (4 (((dentypeconvert3 [15])), dentypeconvert3 [15:4]));

Винаги @ (posedge clk или posedge нулиране)
започва: output_reg_process
ако (нулиране == 1'b1) започва
output_register <= 0;
приключвам
иначе започва
ако (clk_enable == 1'b1) започва
output_register <= output_typeconvert;
приключвам
приключвам
край / / output_reg_process

/ / Назначение Изявления
присвоите filter_out = output_register;

endmodule / / filter_bpf

 
по отношение на въпроса ви за картинните инверсия, основно това е линейна точка трансформацията с формула.

продукция пиксел = максимална стойност - въвеждане пиксел

и ти се говори за бинарни изображения, така че максималната стойност е 1.прилага това всеки пиксел и произтичащата от изображението ще бъде обърнат на дадено изображение.

Вие можете да приложи това с MXN subtractors за MXN изображение.Можете също така да приложат този със сгънати архитектура.а може и да се приложи процесор (Micorblaze) на FPGA и направите това с няколко линии на C.

по отношение на други въпроси, compairing FPGAs с микропроцесори е като compairing ябълки с портокали.мислите на FPGA като море от портите.и на второ място на нещо, което горят върху FPGA не е софтуер.verilog HDL и VHDL не са програмни езици, те са хардуер описание езици.HDLS въпреки че имат много високо ниво на езика (HLL) изгражда, но вие имате DONT насоки за насоки и насоки за функциите в HDLS.

като за RAM ресурси, добре, rsrinivas е в отговор тя.Може би също се нуждаят от овни, ако имате микропроцесорни / microcontroller сърцевината на вашия проект за съхраняване на програмата.

Надявам се, че помага

 
Здравейте приятели
Чудя се дали това
е възможно да ми изпратите
на MATLAB Filter Дизайн HDL Coder, Simulink HDL Coder монтажник файлове.
Бих бъде благодарна, ако можете да ми помогнете
Имате хубаво време
С уважение
alimassster (AT) gmail.com

 
По мое мнение, аз все още считат, FPGA като процесор.Може би не е точно така.Благодаря за помощта.Наистина оценявам това.Моят следващия въпрос е каква е ролята на основните части са в FPGA.Например, FPGA се състои от CLBs, IOBs и IRS.В IOBs се използват за свързване на вътрешните части на FPGA на външния свят.В IRS са използвани за да се свърже всяка CLB в FPGA.Но каква е функцията за CLBs?Благодаря предварително.

 
Въпреки, че тя може да се разглежда като процесор, на FPGA не може да се разглежда като компютър, който изпълнява поредица от машинни инструкции (в нормален софтуер, това са преводите на при-после, случай, за и последователността).

Предполагам IR означава "вътрешна маршрутизация", който е просто група "жици".Къде си мислите, че "Цифрови логика" се намира?

 
Опитайте това описание:
http://en.wikipedia.org/wiki/Fpga

За подробности около CLB, IOB
и т.н., опитайте да преглеждате Spartan-3д данни лист.Това е хубаво модерно евтини FPGA.Започнете с 3 до 5 страници:
http://direct.xilinx.com/bvdocs/publications/ds312.pdf
you design one and drop it inside.

Един FPGA може лесно да бъде микропроцесорни ако
дизайн една и капка го вътре.Или може да е нещо съвсем различно.(Между другото, някои FPGAs предвиждат вградена микропроцесорна разположение, ако имате нужда от нея, като PowerPC вътре в Virtex FX-4.)

Когато дизайн неща вътре в FPGA, което правите цифрова хардуерна дизайн, програмиране не един микропроцесор.Той
е подобен на старите дни, когато сме изградени системи с TTL и CMOS чипове: Вие изготви система блок диаграма, тогава работата на данни и контрол на времето,
а след това изпълнение на логиката с схематични диаграма.Също с FPGA, но сега ние използваме HDL вместо тромав схеми.В FPGA развитието софтуер ви помага да заредите този хардуер дизайн в FPGA.Вие трябва да разберете цифрова хардуерна дизайн преди FPGAs няма много смисъл.

richardyue, по-рано ви попита "Защо имаме нужда от тази страна?"Кои "част" се отнасят към вас?

Мисля, MATLAB
на Filter Дизайн HDL Coder генерира само паралелно аритметична за IIR филтри, не сериен.
Последно редактирано от echo47 на 04 ноември 2006 14:02; редактирано 1 път общо

 
Благодаря, че вие двамата помощ.IR представлява взаимно Resoures.Първо, аз ще прочетете дейташитове внимателно.Аз
съм сигурен, че ще има още няколко въпроса, надявам вие двамата може да продължи да ми помогнеш.Благодаря предварително.

 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top