KutningJo/signal_processing_vorlage
2
0
Fork 18
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: KutningJo:master
Branches Tags
KutningJo:master
erhardtph78456:master
..
compare: erhardtph78456:master
Branches Tags
erhardtph78456:master
KutningJo:master

1 Commits
master ... master

Author SHA1 Message Date
erhardtph78456
a325c8ddb6 Loesung von add sin cos und rand 2024-12-04 08:58:18 +01:00
10 changed files with 236 additions and 300 deletions
Show Stats Expand all files Collapse all files

72
hardware/signal_processing/add.vhd
View File

@ -6,6 +6,7 @@ library work;
use work.reg32.all;
use work.task.all;
-- Anlegen der Variablen des Programms
entity add is
port (
clk : in std_logic;
@ -25,12 +26,30 @@ entity add is
);
end entity add;
-- Signale anlegen
architecture rtl of add is
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_run :integer range 0 to 2;
signal start_value : std_logic;
signal done_value : std_logic;
signal write_value : std_logic_vector( 31 downto 0 );
begin
-- Instanziierung der float_add.vhd
u_float_add : entity work.float_add
port map(
clk => clk,
reset => reset,
start => start_value,
done => done_value,
a => signal_a_readdata,
b => signal_b_readdata,
sum => write_value
);
-- Zustandsautomat fuer die Zustandsswechsel
task_state_transitions : process ( current_task_state, task_start, index ) is
begin
next_task_state <= current_task_state;
@ -40,7 +59,7 @@ begin
next_task_state <= work.task.TASK_RUNNING;
end if;
when work.task.TASK_RUNNING =>
if ( index = work.task.STREAM_LEN - 1 ) then
if ( index = work.task.STREAM_LEN ) then
next_task_state <= work.task.TASK_DONE;
end if;
when work.task.TASK_DONE =>
@ -50,24 +69,55 @@ begin
end case;
end process task_state_transitions;
-- Zustandautomat fuer die Berechnung
sync : process ( clk, reset ) is
begin
if ( reset = '1' ) then
current_task_state <= work.task.TASK_IDLE;
index <= 0;
-- alle Signale in der Reset Bedingung initialisieren
start_value <= '0';
signal_a_read <= '0';
signal_b_read <= '0';
signal_write <= '0';
elsif ( rising_edge( clk ) ) then
current_task_state <= next_task_state;
case next_task_state is
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
when work.task.TASK_RUNNING =>
index <= index + 1;
signal_write <= '1';
signal_writedata <= ( others => '0' );
when work.task.TASK_DONE =>
index <= 0;
signal_write <= '0';
-- idle
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
-- running
when work.task.TASK_RUNNING =>
case index_run is
when 0 =>
signal_writedata <= ( others => '0' );
start_value <= '1';
index_run <= index_run + 1;
when 1 =>
if(done_value = '1') then
start_value <= '0';
signal_write <= '1';
signal_writedata <= write_value;
signal_a_read <= '1';
signal_b_read <= '1';
index_run <= index_run + 1;
end if;
when 2 =>
signal_write <= '0';
signal_a_read <= '0';
signal_b_read <= '0';
index_run <= 0;
index <= index + 1;
end case;
-- done
when work.task.TASK_DONE =>
index <= 0;
end case;
end if;
end process sync;

273
hardware/signal_processing/fft.vhd
View File

@ -1,26 +1,13 @@
------------------------------------------------------------------------
-- fft
--
-- calculation of FFT magnitudes
-- calculation of FFT magnitude
--
-- 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;
@ -35,10 +22,10 @@ library work;
entity fft is
generic (
-- input data width of real/img part
-- input data width of real/img part
input_data_width : integer := 32;
-- output data width of real/img part
-- output data width of real/img part
output_data_width : integer := 32
);
@ -48,10 +35,10 @@ entity fft is
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 )
);
@ -59,103 +46,12 @@ 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;
-- 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 => , -- system clock
-- reset => , -- Active High Asynchronous Reset
-- di_en => , -- Input Data Enable
-- di_re => , -- Input Data (Real)
-- di_im => , -- Input Data (Imag)
-- do_en => , -- Output Data Enable
-- do_re => , -- Output Data (Real)
-- do_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 => , -- system clock
-- reset => , -- Active High Asynchronous Reset
-- input_valid => , -- Input Data Valid
-- input_re => , -- Input Realteil in Fixpoint format
-- input_im => , -- Input Imaginaerteil in Fixpoint format
-- output_valid => , -- Output Data Valid
-- output_magnitude => -- 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
task_state_transitions : process ( current_task_state, task_start, index ) is
begin
next_task_state <= current_task_state;
case current_task_state is
@ -164,7 +60,7 @@ begin
next_task_state <= work.task.TASK_RUNNING;
end if;
when work.task.TASK_RUNNING =>
if ( index = 2 ) then
if ( index = work.task.STREAM_LEN - 1 ) then
next_task_state <= work.task.TASK_DONE;
end if;
when work.task.TASK_DONE =>
@ -174,157 +70,28 @@ begin
end case;
end process task_state_transitions;
-----------------------------------------------------------------------------------------------
-- Zustandsmaschine fuer die eigentliche Ablaufsteuerung fuer die FFT (Uebergangsschaltnetz)
-----------------------------------------------------------------------------------------------
-- Hier soll Ihre Ablaufsteuerung fuer die FFT stehen
-----------------------------------------------------------------------------------------------
-- Ausgangsschaltnetz/Zustandsspeicher fuer die Task und FFT Zustandsmaschine
-----------------------------------------------------------------------------------------------
sync : process ( clk, reset ) is
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;
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
when work.task.TASK_RUNNING =>
index <= index + 1;
signal_write <= '1';
signal_writedata <= ( others => '0' );
when work.task.TASK_DONE =>
index <= 0;
signal_write <= '0';
end case;
end if;
end process sync;
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 <= fft_float_input; -- Der Eingang muss noch entsprechend skaliert werden
-----------------------------------------------------------------------------------------------
--
-- 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 <= data_out_mag_signed_float; -- 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;
task_state <= current_task_state;
end architecture rtl;

40
hardware/signal_processing/rand.vhd
View File

@ -25,6 +25,11 @@ architecture rtl of rand is
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 lfsr : std_logic_vector( 31 downto 0 );
signal lfsr_next : std_logic_vector( 31 downto 0 );
signal bitte : std_logic;
signal exponent : std_logic_vector( 7 downto 0 );
signal ieee754 : std_logic_vector( 31 downto 0 );
begin
task_state_transitions : process ( current_task_state, task_start, index ) is
@ -46,24 +51,39 @@ begin
end case;
end process task_state_transitions;
exponent <= std_logic_vector(to_unsigned(128, 8) + unsigned(lfsr(23 downto 23))) when (lfsr(30) = '1')
else std_logic_vector(to_unsigned(124, 8) + unsigned(lfsr(24 downto 23)));
ieee754 <= lfsr(31) & exponent(7 downto 0) & lfsr(22 downto 0);
bitte <= (lfsr(31) XOR lfsr(21) XOR lfsr(1));
lfsr_next <= lfsr(30 downto 0) & bitte;
sync : process ( clk, reset ) is
begin
if ( reset = '1' ) then
current_task_state <= work.task.TASK_IDLE;
index <= 0;
-- alle Signale in der Reset Bedingung initialisieren
lfsr <= seed;
elsif ( rising_edge( clk ) ) then
current_task_state <= next_task_state;
case next_task_state is
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
when work.task.TASK_RUNNING =>
index <= index + 1;
signal_write <= '1';
signal_writedata <= ( others => '0' );
when work.task.TASK_DONE =>
index <= 0;
signal_write <= '0';
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
lfsr <= seed;
when work.task.TASK_RUNNING =>
signal_write <= '1';
signal_writedata <= ( ieee754 );
lfsr <= lfsr_next;
index <= index + 1;
when work.task.TASK_DONE =>
index <= 0;
signal_write <= '0';
end case;
end if;
end process sync;

70
hardware/signal_processing/sine.vhd
View File

@ -29,8 +29,31 @@ architecture rtl of sine is
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_run :integer range 0 to 2;
signal data_valid : std_logic;
signal busy : std_logic;
signal result_valid : std_logic;
signal angle : signed(31 downto 0);
signal write_value : signed(31 downto 0);
begin
-- Instanziierung der float_sine.vhd
u_float_sine : entity work.float_sine
generic map(
ITERATIONS => 8
)
port map(
clk => clk,
reset => reset,
data_valid => data_valid,
busy => busy,
result_valid => result_valid,
angle => angle,
sine => write_value
);
-- Zustandsautomat fuer die Zustandsswechsel
task_state_transitions : process ( current_task_state, task_start, index ) is
begin
next_task_state <= current_task_state;
@ -40,7 +63,7 @@ begin
next_task_state <= work.task.TASK_RUNNING;
end if;
when work.task.TASK_RUNNING =>
if ( index = work.task.STREAM_LEN - 1 ) then
if ( index = work.task.STREAM_LEN ) then -- - 1 ) then
next_task_state <= work.task.TASK_DONE;
end if;
when work.task.TASK_DONE =>
@ -50,24 +73,49 @@ begin
end case;
end process task_state_transitions;
-- Zustandautomat fuer die Berechnung
sync : process ( clk, reset ) is
begin
if ( reset = '1' ) then
current_task_state <= work.task.TASK_IDLE;
index <= 0;
-- alle Signale in der Reset Bedingung initialisieren
data_valid <= '0';
signal_write <= '0';
angle <= x"00000000";
elsif ( rising_edge( clk ) ) then
current_task_state <= next_task_state;
case next_task_state is
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
when work.task.TASK_RUNNING =>
index <= index + 1;
signal_write <= '1';
signal_writedata <= ( others => '0' );
when work.task.TASK_DONE =>
index <= 0;
signal_write <= '0';
-- idle
when work.task.TASK_IDLE =>
index <= 0;
signal_write <= '0';
-- running
when work.task.TASK_RUNNING =>
case index_run is
when 0 =>
signal_write <= '0';
angle <= angle + signed(step_size);--signed(phase)
data_valid <= '1';
index_run <= index_run + 1;
when 1 =>
data_valid <= '0';
if(result_valid = '1') then
signal_write <= '1';
signal_writedata <= std_logic_vector(write_value);
index_run <= index_run + 1;
end if;
when 2 =>
signal_write <= '0';
index_run <= 0;
index <= index + 1;
end case;
-- done
when work.task.TASK_DONE =>
index <= 0;
signal_write <= '0';
end case;
end if;
end process sync;

21
software/signal_processing/add.c
View File

@ -2,10 +2,23 @@
#include "system/data_channel.h"
#include "system/float_word.h"
int task_add_run( void * task ) {
int task_add_run( void * task )
{
add_config * config = (add_config * ) task;
// TODO
// Nachfolgende Antworten Lesen den FIFO der ersten und zweiten Datenquelle aus
// den jeweils gelesenen Wert mit 4 und speichern das Ergebnis in der Datensenke
for (uint32_t i = 0; i < DATA_CHANNEL_DEPTH; ++i)
{
float a, b;
data_channel_read( config->sources[0], (uint32_t *) & a );
data_channel_read( config->sources[1], (uint32_t *) & b );
float_word c;
c.value = a + b;
data_channel_write( config->sink, c.word );
}
return 0;
return 0;
}

38
software/signal_processing/rand.c
View File

@ -2,11 +2,43 @@
#include "system/hardware_task.h"
#include "system/data_channel.h"
#include "system/float_word.h"
#include <stdio.h>
#include <system.h>
int task_rand_run( void * task ) {
// TODO
// Nachfolgende Anweisungen Schreiben 1024 Mal den seed Wert in den FIFO für Rand
rand_config * config = ( rand_config * ) task;
float_word seed = {.value = config->seed};
return 0;
uint32_t lfsr = seed.word;
uint32_t bit = 0; // Must be 32-bit to allow bit << 31 later in the code
for( uint32_t i = 0; i < DATA_CHANNEL_DEPTH; i++ ) {
float_word res;
uint32_t sign = (lfsr >> 31) & 1;
uint32_t exponent;
uint32_t mantisse = lfsr & 0x7FFFFF;
if((lfsr >> 30) & 1) // MSB exponent
{
exponent = 128 + ((lfsr >> 23) & 1); // 128 to 129
}
else
{
exponent = 124 + ((lfsr >> 23) & 3); // 124 to 127
}
uint32_t ieee754 = (sign << 31) | (exponent << 23) | mantisse;
res.value = ieee754;
data_channel_write( config->base.sink, ieee754);
// fibonacci feedback polynomial: x^31 + x^21 + x^1 + 1
bit = ((lfsr >> 31) ^ (lfsr >> 21) ^ (lfsr >> 1)) & 1;
lfsr = (lfsr << 1) | bit;
}
return 0;
}

15
software/signal_processing/sine.c
View File

@ -1,10 +1,21 @@
#include "system/task_sine.h"
#include "system/data_channel.h"
#include "system/float_word.h"
#include <math.h>
int task_sine_run( void * data ) {
// TODO
// Nachfolgende Anweisungen Schreiben 1024 Mal den Wert 4 in den FIFO für Sinus
sine_config * task = ( sine_config * ) data;
uint32_t data_channel_base = task->base.sink;
data_channel_clear( data_channel_base );
return 0;
for( uint32_t i = 0; i < DATA_CHANNEL_DEPTH; i++ ) {
float_word res;
res.value = task->amplitude * sin((2 * M_PI / task->samples_per_periode) * i + task->phase );
data_channel_write( data_channel_base, res.word );
}
return 0;
}

2
tests/hardware/task_fft/Makefile
View File

@ -11,8 +11,6 @@ verilog_srcs = \
vhdl_srcs = \
../../../hardware/system/reg32.vhd \
../../../hardware/system/avalon_slave.vhd \
../test_utility.vhd \
../test_avalon_slave.vhd \
../../hardware/test_data_channel.vhd \
../../../hardware/system/avalon_slave_transitions.vhd \
../../../hardware/system/task.vhd \

4
tests/hardware/task_fft/test_task_fft.vhd
View File

@ -63,7 +63,7 @@ architecture test of test_task_fft is
variable writedata_float : float32;
variable writedata_real : real;
variable expected_real : real;
variable abs_err : real := 0.6;
variable abs_err : real := 0.5e-1;
variable result : data_array( 0 to work.task.STREAM_LEN - 1 );
variable result_fft : data_array( 0 to work.task.STREAM_LEN - 1 );
file data_file : text;
@ -110,13 +110,11 @@ architecture test of test_task_fft is
std.textio.write( data_file_fft, "]" & LF );
file_close( data_file_fft );
index := 0;
while index < STREAM_LEN loop
writedata_float := to_float( result( index ) );
writedata_real := to_real( writedata_float );
expected_real := work.fft_data.expected( index );
assert_near( writedata_real, expected_real, abs_err );
index := index + 1;
end loop;
file_open( data_file_fft_bit_reversed, "fft_out_bit_reversed.py", write_mode );

1
tests/hardware/task_fft/vsim.wave
View File

@ -1,2 +1 @@
add wave -position end sim:/test_task_fft/dut/*
add wave -position end sim:/test_task_fft/dut/u_fft/*