hardware/signal_processing/add.vhd

@@ -13,8 +13,8 @@ entity add is
 
         task_start : in std_logic;
         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_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_read : out std_logic;				
         signal_a_readdata : in std_logic_vector( 31 downto 0 );
 
         signal_b_read : out std_logic;
@@ -45,12 +45,12 @@ architecture rtl of add is
 	signal current_calc_state : CalcState;
 	signal next_calc_state : CalcState;
 
-	signal ergebnis : signed( 31 downto 0);	--das hier vielleicht zu std_logic_vector oder float
+	signal ergebnis : ?;
 	signal ergebnis_valid : std_logic;
 
 begin
 
-	u_float_add : entity work.float_add --Das hier ist der IP Core !!!
+	u_float_add : entity work.float_add 
 	port map(
 		clk =>		clk,
 		reset =>	reset,
@@ -82,71 +82,84 @@ begin
         end case;
     end process task_state_transitions;
 
-	
+	--Übergangsschaltnetz der Zustandsmaschine für die Berechnung
-	--Übergangsschaltnetz der Zustandsmaschine für die Berechnung ###Fertig
+	calc_state_transitions : process ( all ) is
-	calc_state_transitions: process (all) is
 	begin
 		next_calc_state <= current_calc_state;
-		case current_calc_state is
+		-- ...
-			when CALC_IDLE=>
+	end process calc_state_transitions;
-				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
-	--Zustandsspeicher und Ausgangsschaltnetz zu der Steuerung der Tasks 
+	task_sync : process ( clk, reset ) is
-	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 if;
 	end process task_sync;
 
-	--Zustandsspeicher und Ausgangsschaltnetz zu Berechnung 
+
-	sync : process (clk, reset) is
+    -- Zustandsspeicher und Ausgangsschaltnetz zu Berechnung
-	begin
+    sync : process ( clk, reset ) is
-		if (reset = '1') then
+    begin
-			index <= 0;
+	-- Ablaufsteuerung ueberlegen
-			current_calc_state <= CALC_IDLE;
+        if ( reset = '1' ) then
-			ergebnis <= (others => '0'); 
+            current_task_state <= work.task.TASK_IDLE;
-			ergebnis_valid <= '0';
+            index <= 0;
-			signal_write <= '0';
+		--hier alle Signale zuruecksetzen/initialisieren
-			signal_writedata <= (others => '0'); 
+		start_flag <= '0';
-		elsif (rising_edge( clk)) then
+		done_flag <= '0';
-			current_calc_state <= next_calc_state; 
+
-			ergebnis_valid <= '0';
+        elsif ( rising_edge( clk ) ) then
-			case next_calc_state is 
+            current_task_state <= next_task_state;
-				when CALC_IDLE =>
+            case next_task_state is
-					start_flag <= '0';
+            when work.task.TASK_IDLE =>
-					signal_read <= '0';	--Daten wurden noch nicht verwendet.
+                index <= 0;
-					signal_write <= '0';
+                signal_write <= '0';
-				when CALC_ADD => 				--hier Berechnung mit IP Core?
+            when work.task.TASK_RUNNING =>
-					start_flag <= '1';
+		--starten
-				when CALC_STORE_RESULT =>
+		--wenn: start = 0
-					start_flag <= '0';
+		--A und B Signale anlegen
-					index <= index + 1;
+		--start Signal auf 1 setzen
-					signal_write <= '1';
+		--done Signal auf 0 setzen
-					--signal_writedata <= std_logic_vector( ergebnis ); --Ergebnis schreiben, ergebnis direkt aus IP Core anschliessen
+		if ( task_start = '0') then
-					signal_read <= '1'	--mitteilen, dass die Daten gelesen wurden und jetzt neue Daten angelegt werden sollen
+			--do starten
-			end case;
+		elsif ( task_start = '1' and done = '0' ) then
+			--do warten
+		elsif ( task_start = '1' and done = '1' ) then
+			--do Ergebnis lesen
 		end if;
-	end process sync;
+		
-	task_state <= current_task_state;
+		--warten
+		--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;