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

Sollte theoretisch funktionieren

Browse Source
This commit is contained in:
brandlfl78731 2024-11-20 09:29:10 +01:00
parent c4491f89e0
commit 641e3a6945
1 changed files with 60 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
hardware/signal_processing/add.vhd
View File

@ -83,145 +83,70 @@ begin
end process task_state_transitions; end process task_state_transitions;
--Übergangsschaltnetz der Zustandsmaschine für die Berechnung ###Fertig --Übergangsschaltnetz der Zustandsmaschine für die Berechnung ###Fertig
calc_state_transitions: process (all) is 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 case current_calc_state is
when CALC_IDLE=> when CALC_IDLE=>
if (current_task_state= work.task.TASK_RUNNING) then if (current_task_state= work.task.TASK_RUNNING) then
next_calc_state <= CALC_ADD; next_calc_state <= CALC_ADD;
end if; end if;
when CALC_ADD => when CALC_ADD =>
if (done_flag = '1') then if (done_flag = '1') then
next_calc_state <= CALC_STORE_RESULT; next_calc_state <= CALC_STORE_RESULT;
end if; end if;
when CALC STORE RESULT => when CALC STORE RESULT =>
next_calc_state <= CALC_IDLE; 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
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 case;
end if; end process calc state transitions;
end process task_sync;
--Zustandsspeicher und Ausgangsschaltnetz zu Berechnung
sync : process (clk, reset) is
begin
if (reset = '1') then
index <= 0;
current_calc_state <= CALC_IDLE;
ergebnis <= (others => '0');
ergebnis_valid <= '0';
signal_write <= '0';
signal_writedata <= (others => '0');
elsif (rising_edge( clk)) then
current_calc_state <= next_calc_state;
ergebnis_valid <= '0';
case next_calc_state is
when CALC_IDLE =>
start_flag <= '0';
signal_read <= '0'; --Daten wurden noch nicht verwendet.
signal_write <= '0';
when CALC_ADD => --hier Berechnung mit IP Core?
start_flag <= '1';
when CALC_STORE_RESULT =>
start_flag <= '0';
index <= index + 1;
signal_write <= '1';
--signal_writedata <= std_logic_vector( ergebnis ); --Ergebnis schreiben, ergebnis direkt aus IP Core anschliessen
signal_read <= '1' --mitteilen, dass die Daten gelesen wurden und jetzt neue Daten angelegt werden sollen
end case;
end if;
end process sync;
task_state <= current_task_state;
--signal_read anlegen. im nächsten Takt kann gelesen werden. --Zustandsspeicher und Ausgangsschaltnetz zu der Steuerung der Tasks
--Werte holen, addieren, wieder ablegen task_sync : process (clk, reset) is
--running gibt start-signal an add-StateMachine begin
--IP Core macht nur eine Rechnung if (reset = '1') then
--wenn done signal kommt -> summe lesen current_task_state <= work.task.TASK_IDLE;
--
elsif (rising_edge( clk)) then
-- Zustandsspeicher und Ausgangsschaltnetz zu Berechnung current_task_state <= next_task_state;
sync : process ( clk, reset ) is case next_task_state is
begin when work.task. TASK IDLE => null;
-- Ablaufsteuerung ueberlegen when work.task. TASK_RUNNING => null;
if ( reset = '1' ) then when work.task. TASK_DONE => null;
current_task_state <= work.task.TASK_IDLE; end case;
index <= 0;
--hier alle Signale zuruecksetzen/initialisieren
start_flag <= '0';
done_flag <= '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 =>
--starten
--wenn: start = 0
--A und B Signale anlegen
--start Signal auf 1 setzen
--done Signal auf 0 setzen
if ( task_start = '0') then
--do starten
elsif ( task_start = '1' and done = '0' ) then
--do warten
elsif ( task_start = '1' and done = '1' ) then
--do Ergebnis lesen
end if; end if;
end process task_sync;
--warten --Zustandsspeicher und Ausgangsschaltnetz zu Berechnung
--wenn: start = 1, done = 0 sync : process (clk, reset) is
begin
if (reset = '1') then
--Ergebnis lesen index <= 0;
--wenn: done = 1, start = 1 current_calc_state <= CALC_IDLE;
--wenn done kommt, wert aus sum lesen ergebnis <= (others => '0');
--start nach einem Takt auf 0 setzen? ergebnis_valid <= '0';
index <= index + 1; --inkrement nach erfolgreicher Berechnung. Abbruchbedingung index==1024 signal_write <= '0';
signal_write <= '1'; --hier wird in den Speicher geschrieben signal_writedata <= (others => '0');
signal_writedata <= ( others => '0' ); --eigenes Ergebnis zuweisen elsif (rising_edge( clk)) then
when work.task.TASK_DONE => current_calc_state <= next_calc_state;
index <= 0; ergebnis_valid <= '0';
signal_write <= '0'; case next_calc_state is
end case; when CALC_IDLE =>
end if; start_flag <= '0';
end process sync; signal_read <= '0'; --Daten wurden noch nicht verwendet.
--● Sie müssen sich eine Ablaufsteuerung signal_write <= '0';
--überlegen mit, welcher Sie den IP-Core die von when CALC_ADD => --hier Berechnung mit IP Core?
--den Datenquellen gelesenen Werte zuführen start_flag <= '1';
--und die berechneten Additionen in der when CALC_STORE_RESULT =>
--Datensenke speichern start_flag <= '0';
--● Timing Diagramm des IP-Cors beachten (start index <= index + 1;
--und done Signale des IP-Cores) signal_write <= '1';
--● Die vom FIFO gelesenen Werte und auch das --signal_writedata <= std_logic_vector( ergebnis ); --Ergebnis schreiben, ergebnis direkt aus IP Core anschliessen
--Format in welchen die Werte im FIFO signal_read <= '1' --mitteilen, dass die Daten gelesen wurden und jetzt neue Daten angelegt werden sollen
--gespeichert werden ist float (muss hier nichts end case;
--extra beachtet werden) end if;
--● Es wird eine Berechnung der Addition end process sync;
--durchgeführt und dann die nächste gestartet bis task_state <= current_task_state;
--alle 1024 Werte aus den FIFOs bearbeitet
--wurden
task_state <= current_task_state;
end architecture rtl; end architecture rtl;