hauselthe74767/signal_processing_vorlage
1
0
Fork 0
forked from KutningJo/signal_processing_vorlage
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: hauselthe74767:f5940ef807b9bf4ac38d892fb99a978f5b0808fe
Branches Tags
hauselthe74767:master
KutningJo:master
..
compare: hauselthe74767:641e3a6945377bf0db2106d6caf2e7ada49e0184
Branches Tags
hauselthe74767:master
KutningJo:master

2 Commits
f5940ef807 ... 641e3a6945

Author SHA1 Message Date
brandlfl78731
641e3a6945 Sollte theoretisch funktionieren 2024-11-20 09:29:10 +01:00
brandlfl78731
c4491f89e0 Sollte theoretisch funktionieren - mit muell 2024-11-20 09:27:56 +01:00
1 changed files with 64 additions and 77 deletions
Show Stats Expand all files Collapse all files

141
hardware/signal_processing/add.vhd
View File

@ -13,8 +13,8 @@ entity add is
task_start : in std_logic; task_start : in std_logic;
task_state : out work.task.State; task_state : out work.task.State;
--beide read auf 1 setzen zum lesen, danach wieder auf 0 wenn man fertig gelesen hat
signal_a_read : out std_logic; signal_a_read : out std_logic; --signal_read wird als Bestätigung gesetzt, dass die Daten gelesen wurden, d.h. bei der nächsten rising edge werden die nächsten Daten angelegt.
signal_a_readdata : in std_logic_vector( 31 downto 0 ); signal_a_readdata : in std_logic_vector( 31 downto 0 );
signal_b_read : out std_logic; signal_b_read : out std_logic;
@ -45,12 +45,12 @@ architecture rtl of add is
signal current_calc_state : CalcState; signal current_calc_state : CalcState;
signal next_calc_state : CalcState; signal next_calc_state : CalcState;
signal ergebnis : ?; signal ergebnis : signed( 31 downto 0); --das hier vielleicht zu std_logic_vector oder float
signal ergebnis_valid : std_logic; signal ergebnis_valid : std_logic;
begin begin
u_float_add : entity work.float_add u_float_add : entity work.float_add --Das hier ist der IP Core !!!
port map( port map(
clk => clk, clk => clk,
reset => reset, reset => reset,
@ -82,84 +82,71 @@ begin
end case; end case;
end process task_state_transitions; end process task_state_transitions;
--Übergangsschaltnetz der Zustandsmaschine für die Berechnung
calc_state_transitions : process ( all ) is --Übergangsschaltnetz der Zustandsmaschine für die Berechnung ###Fertig
calc_state_transitions: process (all) is
begin begin
next_calc_state <= current_calc_state; next_calc_state <= current_calc_state;
-- ... case current_calc_state is
end process calc_state_transitions; when CALC_IDLE=>
if (current_task_state= work.task.TASK_RUNNING) then
next_calc_state <= CALC_ADD;
end if;
when CALC_ADD =>
if (done_flag = '1') then
next_calc_state <= CALC_STORE_RESULT;
end if;
when CALC STORE RESULT =>
next_calc_state <= CALC_IDLE;
end case;
end process calc state transitions;
-- Zustandsspeicher und Ausgangsschaltnetz zu der Steuerung der Tasks
task_sync : process ( clk, reset ) is --Zustandsspeicher und Ausgangsschaltnetz zu der Steuerung der Tasks
task_sync : process (clk, reset) is
begin begin
if (reset = '1') then
current_task_state <= work.task.TASK_IDLE;
elsif (rising_edge( clk)) then
current_task_state <= next_task_state;
case next_task_state is
when work.task. TASK IDLE => null;
when work.task. TASK_RUNNING => null;
when work.task. TASK_DONE => null;
end case;
end if;
end process task_sync; end process task_sync;
--Zustandsspeicher und Ausgangsschaltnetz zu Berechnung
-- Zustandsspeicher und Ausgangsschaltnetz zu Berechnung sync : process (clk, reset) is
sync : process ( clk, reset ) is begin
begin if (reset = '1') then
-- Ablaufsteuerung ueberlegen index <= 0;
if ( reset = '1' ) then current_calc_state <= CALC_IDLE;
current_task_state <= work.task.TASK_IDLE; ergebnis <= (others => '0');
index <= 0; ergebnis_valid <= '0';
--hier alle Signale zuruecksetzen/initialisieren signal_write <= '0';
start_flag <= '0'; signal_writedata <= (others => '0');
done_flag <= '0'; elsif (rising_edge( clk)) then
current_calc_state <= next_calc_state;
elsif ( rising_edge( clk ) ) then ergebnis_valid <= '0';
current_task_state <= next_task_state; case next_calc_state is
case next_task_state is when CALC_IDLE =>
when work.task.TASK_IDLE => start_flag <= '0';
index <= 0; signal_read <= '0'; --Daten wurden noch nicht verwendet.
signal_write <= '0'; signal_write <= '0';
when work.task.TASK_RUNNING => when CALC_ADD => --hier Berechnung mit IP Core?
--starten start_flag <= '1';
--wenn: start = 0 when CALC_STORE_RESULT =>
--A und B Signale anlegen start_flag <= '0';
--start Signal auf 1 setzen index <= index + 1;
--done Signal auf 0 setzen signal_write <= '1';
if ( task_start = '0') then --signal_writedata <= std_logic_vector( ergebnis ); --Ergebnis schreiben, ergebnis direkt aus IP Core anschliessen
--do starten signal_read <= '1' --mitteilen, dass die Daten gelesen wurden und jetzt neue Daten angelegt werden sollen
elsif ( task_start = '1' and done = '0' ) then end case;
--do warten
elsif ( task_start = '1' and done = '1' ) then
--do Ergebnis lesen
end if; end if;
end process sync;
--warten task_state <= current_task_state;
--wenn: start = 1, done = 0
--Ergebnis lesen
--wenn: done = 1, start = 1
--wenn done kommt, wert aus sum lesen
--start nach einem Takt auf 0 setzen?
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;
--● Sie müssen sich eine Ablaufsteuerung
--überlegen mit, welcher Sie den IP-Core die von
--den Datenquellen gelesenen Werte zuführen
--und die berechneten Additionen in der
--Datensenke speichern
--● Timing Diagramm des IP-Cors beachten (start
--und done Signale des IP-Cores)
--● Die vom FIFO gelesenen Werte und auch das
--Format in welchen die Werte im FIFO
--gespeichert werden ist float (muss hier nichts
--extra beachtet werden)
--● Es wird eine Berechnung der Addition
--durchgeführt und dann die nächste gestartet bis
--alle 1024 Werte aus den FIFOs bearbeitet
--wurden
task_state <= current_task_state;
end architecture rtl; end architecture rtl;