KutningJo/signal_processing_vorlage
2
0
Fork 26
Code Issues Pull Requests Releases Wiki Activity
signal_processing_vorlage/hardware/signal_processing/fft.vhd
schullersh61298 3844b6a593 Lösung ADD und FFT
2026-01-13 10:02:54 +01:00

433 lines
18 KiB
VHDL
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

------------------------------------------------------------------------
-- fft
--
-- calculation of FFT magnitudes
--
-- Inputs:
-- 32-Bit Floating Point number in range +-16 expected (loaded from FIFO)
--
-- Outputs
-- 32-Bit Floating Point number in range +-16 calculated (stored in FIFO)
--
--
-- Zahlen aus dem Eingangs-FIFO liegen in 32-Bit Floating Point mit Wertebereich +-16 vor
-- Diese Zahlen müssen in Floating Point auf den Wertebereich +-1 gebracht werden (In Floating Point können Sie durch :16 teilen, wenn Sie den Exponenten der Floating Point Zahl um -4 verkleinern, falls dieser ungleich Null ist)
-- Die auf den Wertebereich +-1 gebrachten Floating Point Zahlen mit to_fixed auf eine Fixpointzahl wandeln
-- Diese Fixpointzahl kann dem FFT IP-Core (fftmain) als Eingangswert übergeben werden (Realteil = skalierte auf Fixpoint gewandelte Zahlen; Imaginärteil=0)
-- Die vom FFT IP-Core berechneten werden (Realteil und Imaginärteil) können direkt dem IP-Core für die FFT Magnitude Berechnung (fft_magnitude_calc) übergeben werden (dieser arbeitet auch in Fixpoint im gleichen Wertebereich)
-- Das Ergebnis des FFT Magnitude Berechnung IP-Cores (fft_magnitude_calc) dann auf Floating Point wandeln (to_float)
-- Diese Floating Point Zahlen dann wieder skalieren mit *16 bzw. *32 für den DC-Anteil um auf den ursprünglichen Wertebereich mit +-16 zu kommen (aus dem FFT IP-Core kommt der DC-Anteil / Index 0 um den Faktor 2 zu klein, deswegen dort *32).
-- (In Floating Point können Sie *16 machen, wenn Sie den Exponenten der Floating Point Zahl um +4 vergrößern, *32 wenn dieser um +5 vergrößert wird, falls der Exponent ungleich Null ist)
-- Die Ergebnisse liegen noch in der bit-reveserd order vor (FFT IP-Core arbeitet nicht in-place) und müssen deswegen noch auf die natural order gebracht werden (https://de.mathworks.com/help/dsp/ug/linear-and-bit-reversed-output-order.html)
-- (z.B: ein Array verwenden, um die Werte zu sortieren)
-- Dann das Ergebnis in den Ausgangsfifo speichern
--
-----------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
library work;
use work.reg32.all;
use work.task.all;
use work.float.all;
entity fft is
generic (
-- input data width of real/img part
input_data_width : integer := 32;
-- output data width of real/img part
output_data_width : integer := 32
);
port (
clk : in std_logic;
reset : in std_logic;
task_start : in std_logic;
task_state : out work.task.State;
signal_read : out std_logic;
signal_readdata : in std_logic_vector( 31 downto 0 );
signal_write : out std_logic;
signal_writedata : out std_logic_vector( 31 downto 0 )
);
end entity fft;
architecture rtl of fft is
-- Signale für Task State Machine
signal current_task_state : work.task.State;
signal next_task_state : work.task.State;
signal index : integer range 0 to work.task.STREAM_LEN;
--signal index : integer range 0 to 2000;
-- FFT Ablaufzustandsmaschine
type fft_state_type is (FFT_IDLE, FFT_READ, FFT_WAIT, FFT_WRITE);
signal fft_state : fft_state_type;
signal fft_next_state : fft_state_type;
function scale_exponent(arg : signed; delta : integer) return signed is
variable tmp : signed(arg'range);
begin
tmp := arg;
-- Exponent (Bits 30..23) extrahieren, in signed umwandeln, delta addieren,
-- und Ergebnis wieder als signed zurückschreiben
tmp(30 downto 23) := signed(tmp(30 downto 23)) + to_signed(delta, 8);
return tmp;
end function;
function scale_value(idx : integer) return integer is
begin
if idx = 0 then
return 6; -- DC-Bin → ×64 statt ×32
else
return 5; -- Rest → ×32 statt ×16
end if;
end function;
-- Zähler für eingelesene Samples
signal sample_cnt : integer range 0 to work.task.STREAM_LEN;
-- component des Verilog IP-Cores fuer die FFT
component fftmain is
port(
clock: in std_logic; -- Master Clock
reset: in std_logic; -- Active High Asynchronous Reset
di_en: in std_logic; -- Input Data Enable
di_re: in std_logic_vector(input_data_width-1 downto 0); -- Input Data (Real)
di_im: in std_logic_vector(input_data_width-1 downto 0); -- Input Data (Imag)
do_en: out std_logic; -- Output Data Enable
do_re: out std_logic_vector(output_data_width-1 downto 0); -- Output Data (Real)
do_im: out std_logic_vector(output_data_width-1 downto 0) -- Output Data (Imag)
);
end component;
-- Signale Input skaliert
signal fft_float_input : signed( 31 downto 0 );
signal fft_float_scaled_input : signed( 31 downto 0 );
-- Signale fuer FFT-IP Core
-- fft data input signal
signal fft_input_data_enable: std_logic;
signal data_in_re : std_logic_vector (input_data_width-1 downto 0);
signal data_in_im : std_logic_vector (input_data_width-1 downto 0);
-- fft output data
signal fft_output_valid : std_logic;
signal data_out_re : std_logic_vector (output_data_width-1 downto 0);
signal data_out_im : std_logic_vector (output_data_width-1 downto 0);
-- Signale fuer Magnitude IP-Core
signal fft_mag_calc_valid : std_logic;
signal fft_mag_calc_result: std_logic_vector (output_data_width-1 downto 0);
-- Signale fuer Ergebnis skaliert
signal data_out_mag_signed_float : signed (output_data_width-1 downto 0);
signal fft_float_scaled : signed( 31 downto 0 );
-- Signale/Array um Ergebnisse der FFT in der natural order zu speichern
signal data_memory : work.reg32.RegArray( 0 to 1023 );
signal index_reversed : std_logic_vector(9 downto 0);
signal index_output_sv : std_logic_vector(9 downto 0);
signal index_output : integer range 0 to 1023;
-- Signal um in den Write FIFO zu schreiben
signal wr_fifo : std_logic;
begin
-----------------------------------------------------------------------------------------------
-- Hier muss der Verilog FFT IP-Core instanziert werden
-----------------------------------------------------------------------------------------------
u_fft : fftmain
port map (
clock => clk, -- system clock
reset => reset, -- Active High Asynchronous Reset
di_en => fft_input_data_enable, -- Input Data Enable
di_re => data_in_re, -- Input Data (Real)
di_im => data_in_im, -- Input Data (Imag)
do_en => fft_output_valid, -- Output Data Enable
do_re => data_out_re, -- Output Data (Real)
do_im => data_out_im -- Output Data (Imag)
);
-- fft_output_valid <= '0';
-- data_out_re <= (others => '0');
-- data_out_im <= (others => '0');
-----------------------------------------------------------------------------------------------
-- Hier muss der VHDL Magnitue IP-COre instanziert werden
-----------------------------------------------------------------------------------------------
u_fft_mag_calc : entity work.fft_magnitude_calc
port map (
clk => clk, -- system clock
reset => reset, -- Active High Asynchronous Reset
input_valid => fft_output_valid, -- Input Data Valid
input_re => data_out_re, -- Input Realteil in Fixpoint format
input_im => data_out_im, -- Input Imaginaerteil in Fixpoint format
output_valid => fft_mag_calc_valid, -- Output Data Valid
output_magnitude => fft_mag_calc_result -- Magnitude Output in Fixpoint format
);
-- fft_mag_calc_valid <= '1' when index = 0 else '0';
-- fft_mag_calc_result <= (others => '0');
-----------------------------------------------------------------------------------------------
-- Zustandsmaschine fuer die Taskabarbeitung (Uebergangsschaltnetz)
-----------------------------------------------------------------------------------------------
task_state_transitions : process (all) is
begin
next_task_state <= current_task_state;
case current_task_state is
when work.task.TASK_IDLE =>
if ( task_start = '1' ) then
next_task_state <= work.task.TASK_RUNNING;
end if;
when work.task.TASK_RUNNING =>
if ( index = 2 ) then
next_task_state <= work.task.TASK_DONE;
end if;
when work.task.TASK_DONE =>
if ( task_start = '1' ) then
next_task_state <= work.task.TASK_RUNNING;
end if;
end case;
end process task_state_transitions;
-----------------------------------------------------------------------------------------------
-- Zustandsmaschine fuer die eigentliche Ablaufsteuerung fuer die FFT (Uebergangsschaltnetz)
-- - FFT_IDLE : Warten auf TASK_RUNNING
-- - FFT_READ : STREAM_LEN Samples aus dem Eingangs-FIFO lesen und in FFT schieben
-- - FFT_WAIT : Warten, bis alle FFT-/Magnitude-Ergebnisse im Speicher sind (index wird 1)
-- - FFT_WRITE: Schreiben in Ausgangs-FIFO (gesteuert über vorhandene wr_fifo/index-Logik)
-----------------------------------------------------------------------------------------------
-- Hier soll Ihre Ablaufsteuerung fuer die FFT stehen
fft_next_state_machine : process (all) is
begin
-- Default-Ausgänge
signal_read <= '0';
fft_input_data_enable <= '0';
fft_next_state <= fft_state;
case fft_state is
when FFT_IDLE => -- auf Start der Aufgabe warten
if current_task_state = work.task.TASK_RUNNING then
fft_next_state <= FFT_READ;
end if;
when FFT_READ => -- Eingänge aus FIFO lesen und in FFT schieben
signal_read <= '1';
fft_input_data_enable <= '1';
if sample_cnt = work.task.STREAM_LEN - 1 then
fft_next_state <= FFT_WAIT;
end if;
when FFT_WAIT => -- Warten bis alle Magnitude-Wete im Speicher liegen
if index = 1 then
fft_next_state <= FFT_WRITE;
end if;
when FFT_WRITE =>
if next_task_state = TASK_DONE then
fft_next_state <= FFT_IDLE;
end if;
end case;
end process fft_next_state_machine;
process(clk, reset)
begin
if reset = '1' then
fft_state <= FFT_IDLE;
sample_cnt <= 0;
elsif rising_edge(clk) then
fft_state <= fft_next_state;
if fft_state = FFT_IDLE then
sample_cnt <= 0;
elsif fft_state = FFT_READ then
sample_cnt <= sample_cnt + 1;
end if;
end if;
end process;
-----------------------------------------------------------------------------------------------
-- Ausgangsschaltnetz/Zustandsspeicher fuer die Task und FFT Zustandsmaschine
-----------------------------------------------------------------------------------------------
sync : process ( clk, reset ) is
begin
if ( reset = '1' ) then
current_task_state <= work.task.TASK_IDLE;
index <= 0;
wr_fifo <= '0';
elsif ( rising_edge( clk ) ) then
current_task_state <= next_task_state;
wr_fifo <= '0';
case next_task_state is
when work.task.TASK_IDLE =>
index <= 0;
when work.task.TASK_RUNNING =>
-- Nur damit das Template durchlaueft bei index=0 wird das natural order array mit Nullen gefuellt
-- Bei index=1 werden die 1024 Werte in den Ausgangsfifo geschrieben (Task done bei index=2)
if ( index_output = work.task.STREAM_LEN - 1 ) then
index <= index + 1;
end if;
if index = 1 then
wr_fifo <= '1';
end if;
when work.task.TASK_DONE => null;
end case;
end if;
end process sync;
-----------------------------------------------------------------------------------------------
--
-- Skalierung der Eingangswerte welche vom FIFO gelesen werden
-- Dies soll außerhalb eines Prozesses geschehen damit die gelesenen Werte direkt skaliert werden
-- und im naechsten Takt schon weiter verarbeitet werden können
--
-- Erforderliches Scaling:
--
-- By selecting the amplitude as a power of two (e.g. 2 ** 2) the
-- multiplication is a simple addition of the exponents.
-- In the following calculation the inputs are scaled from FP in range +-16 to FP in range +-1
-- This means an divsion through 16 -> exponent needs an addition of - 4
--
-- fft_float_input = gelesener Wert vom FIFO (floating point)
-- fft_float_scaled_input = soll skalierter Wert vom FIFO seien (floating point)
-- (Anm. Der FFT IP-Core braucht als Format Fix-Point -> noch eine weitere Wandlung erforderlich)
-----------------------------------------------------------------------------------------------
fft_float_input <= signed(signal_readdata);
fft_float_scaled_input <= scale_exponent(fft_float_input, -4); -- E = E-4 Der Eingang muss noch entsprechend skaliert werden
data_in_re <= to_fixed(std_logic_vector(fft_float_scaled_input));
data_in_im <= (others => '0'); -- Imaginärteil = 0
-----------------------------------------------------------------------------------------------
--
-- Skalierung der Eingangswerte welche vom FIFO gelesen werden
-- Dies soll außerhalb eines Prozesses geschehen damit die gelesenen Werte direkt skaliert werden
-- und im naechsten Takt schon weiter verarbeitet werden können
--
-- Erforderliches Scaling:
--
-- By selecting the amplitude as a power of two (e.g. 2 ** 2) the
-- multiplication is a simple addition of the exponents.
-- In the following calculation the inputs are scaled from FP in range +-1 to FP in range +-16
-- the first frequency bin (DC-bin) needs a multiplication by two compared to the other frequency bins (the used fft ip-core divides the result of the first frequency bin by N instead of the correct N/2)
-- This means an divsion through 16 is required for the first frequency bin (DC Part) -> exponent needs an addition of +4
-- This means an divsion through 32 is required for the first frequency bin (DC Part) -> exponent needs an addition of +5
--
-- data_out_mag_signed_float = in float gewandelter Wert der Magnitude Berechnung
-- fft_float_scaled = soll der skalierte float Wert der Magnitude seien
-----------------------------------------------------------------------------------------------
data_out_mag_signed_float <= signed(to_float(fft_mag_calc_result));
fft_float_scaled <= (others => '0')
when fft_mag_calc_valid = '0'
else scale_exponent(
data_out_mag_signed_float,
scale_value(index_output)
);
-- Der Ausgang muss noch entsprechend skaliert werden
-----------------------------------------------------------------------------------------------
-- Der FFT-IP Core liefert das Ergebnis nicht in der natuerlichen Reihenfolge deswegen muss eine
-- Umordnung der Ausgangswerte erfolgen
--
-- index_output_sv = std_logic_vector des Integer Ausgangsindex
-- index_reversed = der reversed Ausgangsindex (wird benoetigt fuer damit man die FFT Ergebnisse in die natuerliche Ordnung bringt
--
c_index_output_sv:
index_output_sv <= std_logic_vector(to_unsigned(index_output, index_reversed'length));
c_reversed_index:
index_reversed <= index_output_sv(0) & index_output_sv(1) & index_output_sv(2) & index_output_sv(3) & index_output_sv(4) & index_output_sv(5) & index_output_sv(6) & index_output_sv(7) & index_output_sv(8) & index_output_sv(9);
-----------------------------------------------------------------------------------------------
-- Prozess steuert das hochzaehlen des Ausgang Index
-----------------------------------------------------------------------------------------------
p_number_output_sample: process ( clk, reset ) is
begin
if ( reset = '1' ) then
index_output <= 0;
elsif ( rising_edge( clk ) ) then
-- Ruecksetz Bedingung für index_output
if index_output = 1023 then -- in diese IF-Bedingung ggf. noch den IDLE Zustand Ihrer FFT FSM einbringen
index_output <= 0;
-- index_output hochzaehlen um in natural order im array zu speichern
elsif fft_mag_calc_valid = '1' then
index_output <= index_output + 1;
-- index_output hochzaehlen um Werte im Ausgangsfifo zu speichern
elsif wr_fifo = '1' then
index_output <= index_output + 1;
end if;
end if;
end process p_number_output_sample;
-----------------------------------------------------------------------------------------------
-- Prozess speichert das skalierte Endergbenis iun der natural order
-----------------------------------------------------------------------------------------------
p_output2float_memory: process ( clk, reset) is
begin
if ( reset = '1' ) then
null;
elsif ( rising_edge( clk ) ) then
if fft_mag_calc_valid = '1' then
data_memory(to_integer(unsigned(index_reversed))) <= std_logic_vector(fft_float_scaled);
end if;
end if;
end process p_output2float_memory;
-----------------------------------------------------------------------------------------------
-- Schreiben der berechneten Werte in den FIFO
-----------------------------------------------------------------------------------------------
p_output_fifo: process ( clk, reset ) is
begin
if ( reset = '1' ) then
signal_writedata <= (others => '0');
signal_write <= '0';
elsif ( rising_edge( clk ) ) then
signal_write <= '0';
if wr_fifo = '1' then
signal_writedata <= data_memory(index_output);
signal_write <= '1';
end if;
end if;
end process p_output_fifo;
-- Hier sollen die sonstigen benoetigten Anweisungen stehen
task_state <= current_task_state;
end architecture rtl;
Reference in New Issue View Git Blame Copy Permalink