FPGA의

R

richardyue

Guest
안녕하세요, 회원,
여기서 질문이있습니다.어떤 시스템에서 FPGA의 역할은 무엇입니까?희망이 거기로 가능한 많은 구성원이 주제에 dicussing 것입니다.나는 나에게 많은 혼란 가지고 있던 질문을 많이했다.미리 감사드립니다.

 
FPGA의 아름다움 거의 아무것도 디지털 될 수있습니다.당신은 그것의 역할을 정의할 수있습니다.FPGA를 비정상적으로 구성할 수있습니다.ASIC는 달리, FPGA 개발을 완벽하게 벤치에 행할 수있습니다.당신이 소프트웨어를 설치, 저렴한 개발 키트를 구입할 수 있으며 바로 실험을 시작합니다.당신은, 알고리즘 및 애플 리케이션 개발 및 작은 보드에 그들을 테스트합니다.간단한 실험을 단 몇 분 정도 걸릴.

어서 당신의 수많은 질문을 부탁드립니다.많다네 여기에 대답했다.물론, 일반적인 답변 (또는 Google)이 포럼 검색하시기 바랍니다.

 
친애하는 echo47,
도와 주셔서 감사합니다.날 구체적인 것들을 만들어 보자.만약 내가 시스템을 설계, 어떤 이미지를 만들 수있습니다 반비례합니다.만약 이미지에 지점 pix 0, 다음이 시스템은 후에이 그것입니다 지점 pix 1이 될것이다.우리가 어떻게 FPGA를 사용하여이 기능을 어떻게 구현합니까?

 
richardyue 썼습니다 :

친애하는 echo47,

도와 주셔서 감사합니다.
날 구체적인 것들을 만들어 보자.
만약 내가 시스템을 설계, 어떤 이미지를 만들 수있습니다 반비례합니다.
만약 이미지에 지점 pix 0, 다음이 시스템은 후에이 그것입니다 지점 pix 1이 될것이다.
우리가 어떻게 FPGA를 사용하여이 기능을 어떻게 구현합니까?
 
반전으로, 당신이 백인으로 흑인 / 백인 이미지로 변환 / 블랙 바라는 것 같은데.하지만 "이미지"가 너무 모호 하군요.그 프로젝트의 사소한 (이 cfriend 설명)에 이르기까지 거의 불가능하다 아무것도 (모든 가능한 이미지 형식 및 입력 인코딩 / 지원하고있을 출력 방법).

 
FPGA를 하나의 hotests EA의 구성 요소를이 시간에있습니다.

당신이 원하는 모든 것을 할 병렬 - VHDL에서 "프로그래밍,하지만 당신이 그 마이크로 프로세서, 운영 체제의 같은 작은 리눅스의 대부분에 설치할 수있는 그 시절의 FPGA이나 보드에 코어 마이크로 소프트가 ...어디에 소프트웨어를 쓸 수있습니다.

일부의 FPGA 제조 업체 (예를 들어 http://www.Actel.com 자신의 FPGA에 아날로그 블록을 통합하는 - ARM7 코어와 "융합).

그래서 FPGA를 시스템 자체에있을 수있습니다 ..

만약 당신이 비전에 뭔가 원하는 게 / 이미지 프로세싱의 NI LabVIEW 비전하려고 줄 수있습니다 : 여기서의 NI LabVIEW를 사용하여이 보드 FPGA를 프로그램할 수있습니다 비전 어플 리케이션을 위해 만든 특별하다!

확인 :

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

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

 
우리의 FPGA 프로세서의 CPU처럼 말할 수 있습니까?만약 내가 디지털 회로 설계, 예를 들어, 원하는, 내가 어떤 언급도, 우리는 블랙 박스로 FPGA를 고려할 수있습니다.우리는 FPGA의 기능을 자일링스는 ISE 또는 Maxplus II와 같은 소프트웨어를 사용하여 정의할 수있습니다.맞죠?내 바보 같은 질문 죄송합니다.

 
당신 picoblaze의 FPGA와 같은 RISC의 MCU 코어를 가질 수있습니다
또는 microblaze 같은 소프트 프로세서 코어
그들은 둘 다 자일링스의 FPGA에있습니다

 
안녕
FPGA의 역할이다
U 설계 뭔가 합성 및 시뮬레이션.그것을 잘 작동하지만, 그것을 할 때 칩으로 조작 U 작동하지 않을 수있습니다.거기있어 문제가 하드웨어 문신 소프트웨어 관련 처리할 수없습니다.
U 마스크 이렇게하면 작동하지 않는 경우 나중에 회개 synthesised RTL과 조작에 필요한 루피의 crores 지출 wan't하지 않습니다.
U FPGA를 누른 다음 계속 그것의 기능을 확인 넣고.
U 돈도 더 나은 제품 회로 저장할 수있습니다

 
FPGA를 거대한 디지털 breadboard 게이트의 전체, 비치 샌들, RAM의처럼, 및 기타 로직 디바이스입니다.당신은 당신이 원하는 거의 모든 빌드 당신이 원하는 거의 모든 방법으로 그들을 인터커넥트 수있습니다.당신이 동시에 .. 사용자 정의 마이크로 프로세서, 또는 이더넷 컨트롤러 또는 비디오 아케이드 게임, 디지털 필터, 또는 은행 암호화 / 암호 해독 장치, 또는 음악을 합성하거나, 디지털 라디오, 아니면 모든 것들을 만들 수 .

글쎄, 아마 모든 것들을 동시에 당신의 작은 FPGA를 구입!

<img src="http://www.edaboard.com/images/smiles/icon_wink.gif" alt="윙크" border="0" />echo47에 의해 2006년 11월 3일 12시 33분에 편집한 마지막으로, 1 시간을 편집한 총

 
안녕하세요 에코
내가 FPGA를 bandpass 디지털 IIR 필터의 은행 건물이다.어떤 제안.

 
에는 FIR 및 IIR 필터를 설계하는 쉬운 방법 중 하나 MATLAB의 필터를 설계 HDL을 코더를 사용하는 것입니다.당신은 어떤 버튼을 클릭하면 디자인 매개 변수를 입력하고 그것을 밖으로 준비 - VHDL 또는 Verilog를 사용 줄거다.
http://www.mathworks.com/access/helpdesk/help/toolbox/hdlfilter/

그러나, 만약 당신과 같은 몇 가지 필터를 컴퓨터로 여러 작업을 할 로직을 하나의 덩어리를 사용하려면, 당신은 아마 MATLAB의 출력을 수정해야합니다.

또한 시뮬 링크 HDL을 코더와 같은 수있습니다.
http://www.mathworks.com/access/helpdesk/help/toolbox/slhdlcoder/

 
내가 FPGA의 기본적인 내부 구조를 알아.그것은 내가 구성 / O를 차단, CLB 및 인터커넥트 자원.일부 FPGA 디바이스에서는, 블록 RAM이있다.왜 우리가이 부분이 필요합니까?

 
나중에
난 문신 필터를 생성하는 데 사용했다.
어떻게 이런 효율적인 코드입니다.
내가 fdatool 및 필터 설계 코더 HDL을 사용 해왔다.
내가이 생성된 하나의 필터를 사용할 수와 Verilog 필터 코드에서 매개 변수 계수 ROM에 저장하여 직렬 아키텍처를 개발할 수있습니다.

내가 감수해야 Verilog 코드를 첨부 (미안하다 거울을 업로드하는 방법을) 모르겠어요

/ / ------------------------------------------------ -------------
/ /
/ / 모듈 : filter_bpf
/ /
/ / MATLAB (R)의 7.0.4 및 필터 설계 HDL을 코더 1.2에 의해 생성된.
/ /
/ /에서 생성된 : 2006년 9월 18일 22시 22분 37초
/ /
/ / BPF 850 1150 순서 6
/ /
/ / ------------------------------------------------ -------------

/ / ------------------------------------------------ -------------
/ / HDL을 코드 생성 옵션 :
/ /
/ / TargetLanguage : Verilog
/ / 이름 : filter_bpf
/ / usercomment : BPF 850 1150 순서 6
/ / InlineConfigurations : 끄기
/ / SafeZeroConcat : 끄기
/ / CastBeforeSum :에
/ / TestBenchName : filter_tb_bpf
/ / TestBenchStimulus : 진입로 단계 처프
/ /
/ / 필터 설정 :
/ /
/ / 개별 - 시간 IIR 필터 () 진짜
/ / -------------------------------
/ / 필터 구조 : 직접 - 폼 나는 두번째 주문 섹션
/ / 번호 섹션 : 3
/ / 안정 : 예
/ / 선형 차 : 없음
/ / 산술 : 고정
/ / 분자 : s16, 14 - "[-2 2)
/ / Denominator : s16, 14 - "[-2 2)
/ / 스케일 값 : s16, 14 - "[-2 2)
/ / 입력 : s16, 15 - "[-1 1)
/ / 출력 : s16, 11 - "[-16 16)
/ / 분자 상태 : s16, 15 - "[-1 1)
/ / Denominator 주 : s16, 15 - "[-1 1)
/ / 분자 생산성 : s32, 29 - "[-4 4)
/ / Denominator 생산성 : s32, 29 - "[-4 4)
/ / 분자 Accum : S40 라인업, 29 - "[-1024 1024)
/ / Denominator Accum : S40 라인업, 29 - "[-1024 1024)
/ / 회전 모드 : 바닥
/ / 오버플로 모드 : 포화
/ / 합계 전에 주연 항목 : true
/ / ------------------------------------------------ -------------

`timescale 1 ns의 / 1 ns의

모듈 filter_bpf (CLK,,, 리셋 clk_enable filter_in, filter_out);

입력 CLK;
입력 clk_enable;
입력 재설정;
입력 서명 [15시] filter_in; / / sfix16_En15
출력 서명 [15시] filter_out; / / sfix16_En11

/ / 로컬 함수
/ / 타입 정의
/ / 상수
매개 변수는 서명 [15시] scaleconst1 = 16'b0000000101011010; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b1_section1 = 16'b0100000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b2_section1 = 16'b0000000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b3_section1 = 16'b1100000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_a2_section1 = 16'b1000001100101000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_a3_section1 = 16'b0011111001111001; / / sfix16_En14
매개 변수는 서명 [15시] scaleconst2 = 16'b0000000101011010; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b1_section2 = 16'b0100000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b2_section2 = 16'b0000000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b3_section2 = 16'b1100000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_a2_section2 = 16'b1000001000100101; / / sfix16_En14
매개 변수는 서명 [15시] coeff_a3_section2 = 16'b0011111011010010; / / sfix16_En14
매개 변수는 서명 [15시] scaleconst3 = 16'b0000000101010111; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b1_section3 = 16'b0100000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b2_section3 = 16'b0000000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_b3_section3 = 16'b1100000000000000; / / sfix16_En14
매개 변수는 서명 [15시] coeff_a2_section3 = 16'b1000001111101100; / / sfix16_En14
매개 변수는 서명 [15시] coeff_a3_section3 = 16'b0011110101010010; / / sfix16_En14
/ / 신호
서명 reg [15시] input_register; / / sfix16_En15
와이어 서명 [15시] 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시] numtypeconvert1; / / sfix16_En15
와이어 서명 [15시] dentypeconvert1; / / sfix16_En15
서명 reg [15시] numdelay_section1 [0시 1분]; / / sfix16_En15
서명 reg [15시] 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시] 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시] 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시] numtypeconvert2; / / sfix16_En15
와이어 서명 [15시] dentypeconvert2; / / sfix16_En15
서명 reg [15시] numdelay_section2 [0시 1분]; / / sfix16_En15
서명 reg [15시] 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시] 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시] 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시] numtypeconvert3; / / sfix16_En15
와이어 서명 [15시] dentypeconvert3; / / sfix16_En15
서명 reg [15시] numdelay_section3 [0시 1분]; / / sfix16_En15
서명 reg [15시] 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시] 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시] output_typeconvert; / / sfix16_En11
서명 reg [15시] 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

= input_register * scaleconst1 mul_temp 할당;
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 할당;

= b1sum1 add_cast 할당;
할당 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];

= b2sum1 sub_cast 할당;
할당 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

/ / 할당 계산서
= output_register filter_out 할당;

endmodule / / filter_bpf

 
, 기본적으로 수식과 선형 변환 시점의 이미지 반전에 대한 귀하의 질문에 대해.

출력 픽셀 = 최대의 가치 - 입력 픽셀

당신은 바이너리 이미지에 대해, 그래서 최대 값이 1이면 얘기입니다.각각의 모든 픽셀과 결과 이미지를이 적용 주어진 이미지의 반전 될 것입니다.

당신 MXN 이미지 MXN subtractors이 구현할 수있습니다.또한 접혀 아키텍처와 함께 구현할 수있습니다.또는 당신의 FPGA에 대한 프로세서 (Micorblaze)을 구현할 수와 C의 몇 라인이 없어

, 마이크로 프로세서와 FPGA를 compairing 다른 질문에 대한 사과와 오렌지와 compairing 같다.FPGA의 게이트의 바다라고 생각해.그리고 당신의 FPGA 화상 둘째 것은 소프트웨어이다.HDL을 Verilog 및 VHDL 프로그래밍 언어가 아니라, 그들의 하드웨어 설명 언어입니다.비록 많은 HDLs 높은 수준의 언어 (HLL)가 구성,하지만 당신은 포인터와 포인터 HDLs에서 함수를 포인터를 가지고 있겠지.

로 RAM을 자원, 글쎄, rsrinivas 대답했다.만약 당신이 마이크로 프로세서 / 마이크로 컨트롤러 코어는 귀하의 설계 프로그램을 저장할 수도 RAM의해야 할 수도있습니다.

제가 도움이 되었으면 좋겠

 
안녕 친구
당신이 MATLAB의 필터를 설계 HDL을 코더, 시뮬 링크 HDL을 코더 설치 프로그램이 파일을 보내주 경우 가능성이 있지 않을까.
만약 당신이 나를 도와 줄래 내가 감사할 줄
좋은 시간 되세요
안부
alimassster (시) gmail.com

 
내 생각에, 난 여전히 프로세서로 FPGA를 고려하십시오.정확하지 아마이다.귀하의 모든 도움을 주셔서 감사합니다.정말 감사합니다.나의 다음 질문은 주요 부품의 역할을 FPGA에서 어떤있습니다.예를 들어, FPGA를 CLBs, IOBs 국세청으로 구성되어있습니다.IOBs 바깥 세상과 FPGA의 내부 부품에 연결하는 데 사용됩니다.국세청의 FPGA 각 CLB에 연결하는 데 사용됩니다.하지만 CLBs에 대한 함수입니까?미리 감사드립니다.

 
비록 프로세서로 볼 수있습니다 FPGA를 정상적인 소프트웨어 (기계 지침의 순서를 실행하는 컴퓨터로, 그 다음을한다면, 사건의 번역, 그리고 시퀀싱) 볼 수없습니다.

내가 IR 뉴스 "단순히"전선 "의 무리 내부 라우팅을"의미 있다고 가정합니다.어디로 "디지털 로직"위치라고 생각합니까?

 
이 설명을보십시오 :
http://en.wikipedia.org/wiki/Fpga

CLB, IOB 등에 대한 자세한 내용을 보려면 스파르탄 - 3E 데이터 시트를 탐색하십시오.그것은 좋은 현대 저렴한 FPGA의.5를 통해 3 시작 페이지 :
http://direct.xilinx.com/bvdocs/publications/ds312.pdf
you design one and drop it inside.

FPGA를 쉽게 마이크로 프로세서를하면
하나의 디자인과 내부 드롭하실 수있습니다.아니면 완전히 다를 수있습니다.만약 당신이 파워 PC와 같은 버텍스 - 4 FX는 안으로 그것을 필요가있다 (그건 그렇고, 어떤 FPGA는 임베디드 마이크로 프로세서를 사용할 수있습니다.)

언제 물건의 FPGA 설계 내부에, 당신은, 마이크로 프로세서 프로그래밍되지 디지털 하드웨어를 설계하고있습니다.그 옛날 우리가 TTL 및 CMOS 칩을 탑재한 시스템을 구축하고 비슷한데 : 당신은 그때 그때의 데이터 및 제어 타이밍 자세한 내용은 잘 배선 다이어그램와 로직을 구현하는 시스템의 블록 다이어그램을 그립니다.FPGA와,하지만 지금은 우리가 대신 같은 꼴사나운 도식 HDL을 사용합니다.FPGA 개발 소프트웨어를로드하는 데 도움이 FPGA에 하드웨어 설계.이전에 FPGA를 많이 이해하게한다 당신이 디지털 하드웨어 디자인을 이해해야합니다.

richardyue, 이전에 "왜 우리가이 부분은 필요하지달라고?"어떤 "부분을"당신을 말하는거야?

내가 MATLAB의 필터를 설계 HDL을 코더 IIR 필터, 시리얼 안에 대해서만 병렬 연산을 생성 같아요.
echo47에 의해 2006년 11월 4일 13시 2분에 편집한 마지막으로, 1 시간을 편집한 총

 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top