crc_Lösung

hardware/signal_processing/add.vhd

@@ -8,81 +8,79 @@ library work;
 
 entity add is
     port (
-        clk : in std_logic;
+        clk   : in std_logic;
         reset : in std_logic;
 
         task_start : in std_logic;
         task_state : out work.task.State;
 
-        signal_a_read : out std_logic;
+        signal_a_read     : out std_logic;
-        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;
-        signal_b_readdata : in std_logic_vector( 31 downto 0 );
+        signal_b_readdata : in  std_logic_vector(31 downto 0);
 
-        signal_write : out std_logic;
+        signal_write     : out std_logic;
-        signal_writedata : out std_logic_vector( 31 downto 0 )
+        signal_writedata : out std_logic_vector(31 downto 0)
     );
 end entity add;
 
-u_add: entity word.add
-    port map (
-        clk => clk,
-        reset => reset,
-        
-        task_start => task_start,
-        task_state => task_state,
-        
-        signal_a_read => signal_a_read,
-        signal_a_readdata => signal_a_readdata,
-        
-        signal_b_read => signal_b_read,
-        signal_b_readdata => signal_b_readdata,
-        
-        signal_write => signal_write,
-        signal_writedata => signal_writedata
-);
-
-        
-    
-    
 architecture rtl of add is
+
     signal current_task_state : work.task.State;
-    signal next_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 work.task.STREAM_LEN;
-    signal state : integer range 0 to 255;
+
-    signal reset : integer range 0 to 7;
+
-    signal start : integer range 0 to 7;
+    type AddState is (
-    signal done : integer range 0 to 7;
+        ADD_IDLE,
-    signal A : STD_LOGIC_VECTOR(31 downto 0);
+        ADD_READ_FIFO,
-    signal B : STD_LOGIC_VECTOR(31 downto 0);
+        ADD_LATCH_INPUTS,
-    signal sum : STD_LOGIC_VECTOR(31 downto 0);
+        ADD_START_CALC,
+        ADD_WAIT_DONE,
+        ADD_STORE_RESULT
+    );
+
+    signal current_add_state : AddState;
+    signal next_add_state    : AddState;
+
+    signal start_proc : std_logic;
+    signal done       : std_logic;
+
+    signal A   : std_logic_vector(31 downto 0);
+    signal B   : std_logic_vector(31 downto 0);
+    signal sum : std_logic_vector(31 downto 0);
 
 begin
 
+
     u_float_add : entity work.float_add
         port map (
-            clk => clk,
+            clk   => clk,
             reset => reset,
-            start => start,
+            start => start_proc,
-            done => done,
+            done  => done,
-            A => A,
+            A     => A,
-            B => B,
+            B     => B,
-            sum => sum
+            sum   => sum
         );
 
+
     task_state_transitions : process ( current_task_state, task_start, index ) 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 = work.task.STREAM_LEN - 1 ) 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;
@@ -90,38 +88,107 @@ begin
         end case;
     end process task_state_transitions;
 
+
+    add_state_transitions : process ( current_add_state, current_task_state, done ) is
+    begin
+        next_add_state <= current_add_state;
+
+        if (current_task_state /= work.task.TASK_RUNNING) then
+            next_add_state <= ADD_IDLE;
+        else
+            case current_add_state is
+                when ADD_IDLE =>
+                    next_add_state <= ADD_READ_FIFO;
+                when ADD_READ_FIFO =>
+                    next_add_state <= ADD_LATCH_INPUTS;
+                when ADD_LATCH_INPUTS =>
+                    next_add_state <= ADD_START_CALC;
+                when ADD_START_CALC =>
+                    next_add_state <= ADD_WAIT_DONE;
+                when ADD_WAIT_DONE =>
+                    if done = '1' then
+                        next_add_state <= ADD_STORE_RESULT;
+                    end if;
+                when ADD_STORE_RESULT =>
+                    next_add_state <= ADD_READ_FIFO;
+            end case;
+        end if;
+    end process;
+
+
     sync : process ( clk, reset ) is
     begin
         if ( reset = '1' ) then
             current_task_state <= work.task.TASK_IDLE;
-            signal_a_read <= 'O';
+            index              <= 0;
-            signal_b_read <= 'O';
+
-            signal_write <= 'O';
+            current_add_state <= ADD_IDLE;
-            signal_Writedata <= (others => '0');
+
-            index <= 0;
+            signal_a_read   <= '0';
-            state <= 0;
+            signal_b_read   <= '0';
-            sum <= 0;
+            signal_write    <= '0';
-            done <= 0;
+            signal_writedata <= (others => '0');
-            start <= 0;
+
+            start_proc <= '0';
+            A          <= (others => '0');
+            B          <= (others => '0');
+
+
         elsif ( rising_edge( clk ) ) then
+
             current_task_state <= next_task_state;
+            current_add_state  <= next_add_state;
+
+
+            signal_a_read <= '0';
+            signal_b_read <= '0';
+            signal_write  <= '0';
+            start_proc    <= '0';
+
+
             case next_task_state is
-            when work.task.TASK_IDLE =>
+                when work.task.TASK_IDLE =>
-                index <= 0;
+                    index <= 0;
-                signal_write <= '0';
+
-            when work.task.TASK_RUNNING =>
+                when work.task.TASK_RUNNING =>
-                index <= index + 1;
+                    if current_add_state = ADD_STORE_RESULT then
-                --signal_a_read <= '1' ;
+                        index <= index + 1;
-                --signal_b_read <= '1' ;
+                    end if;
-                signal_write <= '1';
+
-                signal_writedata <= ( others => '0' );
+                when work.task.TASK_DONE =>
-            when work.task.TASK_DONE =>
+                    index <= 0;
-                index <= 0;
-                signal_write <= '0';
             end case;
+
+
+            case next_add_state is
+                when ADD_IDLE =>
+                    null;
+
+                when ADD_READ_FIFO =>
+                    signal_a_read <= '1';
+                    signal_b_read <= '1';
+
+                when ADD_LATCH_INPUTS =>
+                    A <= signal_a_readdata;
+                    B <= signal_b_readdata;
+
+                when ADD_START_CALC =>
+                    start_proc <= '1';
+
+                when ADD_WAIT_DONE =>
+                    start_proc <= '1';
+                    null;
+
+                when ADD_STORE_RESULT =>
+                    signal_write    <= '1';
+                    signal_writedata <= sum;
+            end case;
+
+
         end if;
     end process sync;
 
     task_state <= current_task_state;
 
 end architecture rtl;
+

hardware/signal_processing/crc.vhd

@@ -23,54 +23,104 @@ entity crc is
 end entity crc;
 
 architecture rtl of crc 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;
     
+    constant CRC_INIT : std_logic_vector(31 downto 0) := X"FFFFFFFF";
+    constant CRC_POLY : std_logic_vector(31 downto 0) := X"EDB88320";
+    
+    signal crc_reg : std_logic_vector(31 downto 0) := CRC_INIT;
+    signal data_reg : std_logic_vector(31 downto 0);
+    signal data_ready : std_logic := '0';
+
 begin
+    task_state <= current_task_state;
+
     task_state_transitions : process ( current_task_state, task_start, index ) is
     begin
         next_task_state <= current_task_state;
         case current_task_state is
             when work.task.TASK_IDLE =>
-                if ( task_start = '1' ) then
+                if task_start = '1' then
                     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 =>
-                if ( task_start = '1' ) then
+                if task_start = '1' then
                     next_task_state <= work.task.TASK_RUNNING;
                 end if;
         end case;
-    end process task_state_transitions;
+    end process;
 
-    sync : process ( clk, reset ) is
+    signal_read <= '1' when current_task_state = work.task.TASK_RUNNING 
-    begin
+                             and data_ready = '0' 
-        if ( reset = '1' ) then
+                             and index < work.task.STREAM_LEN 
-            current_task_state <= work.task.TASK_IDLE;
+                  else '0';
-            index <= 0;
+    
-        elsif ( rising_edge( clk ) ) then
+    signal_write <= '1' when current_task_state = work.task.TASK_DONE else '0';
-            current_task_state <= next_task_state;
+    
-            case next_task_state is
+    signal_writedata <= crc_reg xor X"FFFFFFFF";
+
+sync : process ( clk, reset ) is
+    variable temp_crc : std_logic_vector(31 downto 0);
+begin
+    if reset = '1' then
+        current_task_state <= work.task.TASK_IDLE;
+        index <= 0;
+        crc_reg <= CRC_INIT;
+        data_reg <= X"00000000";
+        data_ready <= '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';
+                crc_reg <= CRC_INIT;
+                data_ready <= '0';
+                data_reg <= X"00000000";
+                
             when work.task.TASK_RUNNING =>
-                index <= index + 1;
+                -- DATA LESEN (Timing korrekt)
-                signal_write <= '1';
+                if signal_read = '1' then
-                signal_writedata <= ( others => '0' );
+                    data_reg <= signal_readdata;
+                    data_ready <= '1';
+                end if;
+                
+                -- CRC UPDATE (INDEX PRÜFEN VOR Update!)
+                if data_ready = '1' then
+                    -- WICHTIG: Index bleibt gleich bis TASK_DONE triggert!
+                    --temp_crc := crc_reg xor data_reg;  -- Berechne aber schreibe nicht sofort
+                    
+                    temp_crc := crc_reg xor data_reg;
+                    for i in 0 to 31 loop
+                        if temp_crc(0) = '1' then
+                            temp_crc := std_logic_vector(shift_right(unsigned(temp_crc), 1)) xor CRC_POLY;
+                        else
+                            temp_crc := std_logic_vector(shift_right(unsigned(temp_crc), 1));
+                        end if;
+                    end loop;
+                    
+                    crc_reg <= temp_crc;
+                    data_ready <= '0';
+                    
+                    -- INDEX NUR erhöhen wenn NICHT letzter!
+                    if index < work.task.STREAM_LEN then
+                        index <= index + 1;
+                    end if;  -- Bei index=1023: bleibt 1023 → TASK_DONE triggert!
+                end if;
+                
             when work.task.TASK_DONE =>
                 index <= 0;
-                signal_write <= '0';
+                data_ready <= '0';
-            end case;
+        end case;
-        end if;
+    end if;
-    end process sync;
+end process sync;
 
-    task_state <= current_task_state;
 
 end architecture rtl;
-

hardware/signal_processing/sine.vhd

@@ -30,7 +30,33 @@ architecture rtl of sine is
     signal next_task_state : work.task.State;
     signal index : integer range 0 to work.task.STREAM_LEN;
     
+    signal angle_reg      : signed(31 downto 0);
+    signal step_size_s    : signed(31 downto 0);
+    signal phase_s        : signed(31 downto 0);
+
+    signal fs_data_valid  : std_logic;
+    signal fs_busy        : std_logic;
+    signal fs_result_valid: std_logic;
+    signal fs_sine        : signed(31 downto 0);
+
+    signal sine_sample    : std_logic_vector(31 downto 0);
+    signal fs_result_valid_d : std_logic;
+
 begin
+    u_float_sine : entity work.float_sine
+        generic map (
+            ITERATIONS => 8
+        )
+        port map (
+            clk          => clk,
+            reset        => reset,
+            data_valid   => fs_data_valid,
+            busy         => fs_busy,
+            result_valid => fs_result_valid,
+            angle        => angle_reg,
+            sine         => fs_sine
+        );
+            
     task_state_transitions : process ( current_task_state, task_start, index ) is
     begin
         next_task_state <= current_task_state;
@@ -51,23 +77,77 @@ begin
     end process task_state_transitions;
 
     sync : process ( clk, reset ) is
+        
+        variable sine_word      : std_logic_vector(31 downto 0);
+        variable sign_bit       : std_logic;
+        variable exp_bits       : unsigned(30 downto 23);
+        variable man_bits       : std_logic_vector(22 downto 0);
+
+        variable amp_exp        : unsigned(30 downto 23);
+        variable new_exp        : unsigned(30 downto 23);
+    
     begin
         if ( reset = '1' ) then
             current_task_state <= work.task.TASK_IDLE;
             index <= 0;
+            angle_reg          <= (others => '0');
+            step_size_s        <= (others => '0');
+            phase_s            <= (others => '0');
+            fs_data_valid      <= '0';
+            signal_write       <= '0';
+            signal_writedata   <= (others => '0');
+            sine_sample        <= (others => '0');
+            fs_result_valid_d <= '0';
+            
         elsif ( rising_edge( clk ) ) then
             current_task_state <= next_task_state;
+
+            fs_data_valid <= '0';
+            signal_write  <= '0';
+            
+            fs_result_valid_d <= fs_result_valid;
+
             case next_task_state is
-            when work.task.TASK_IDLE =>
+                
-                index <= 0;
+                when work.task.TASK_IDLE =>
-                signal_write <= '0';
+                    index       <= 0;
-            when work.task.TASK_RUNNING =>
+                    step_size_s <= signed( step_size );
-                index <= index + 1;
+                    phase_s     <= signed( phase );
-                signal_write <= '1';
+                    angle_reg   <= signed( phase );
-                signal_writedata <= ( others => '0' );
+
-            when work.task.TASK_DONE =>
+                
-                index <= 0;
+                when work.task.TASK_RUNNING =>
-                signal_write <= '0';
+
+                    if (index = 0 and fs_busy = '0') then
+                        fs_data_valid <= '1';
+                    end if;
+
+                    if (fs_result_valid = '1' and fs_result_valid_d = '0') then
+                        sine_word := std_logic_vector(fs_sine);
+                        sign_bit  := sine_word(31);
+                        exp_bits  := unsigned(sine_word(30 downto 23));
+                        man_bits  := sine_word(22 downto 0);
+
+                        amp_exp := unsigned(amplitude(30 downto 23));
+                        new_exp := exp_bits + (amp_exp - to_unsigned(127, 8));
+
+                        sine_word(31)           := sign_bit;
+                        sine_word(30 downto 23) := std_logic_vector(new_exp);
+                        sine_word(22 downto 0)  := man_bits;
+
+                        signal_write     <= '1';
+                        signal_writedata <= sine_word;
+
+                        angle_reg <= angle_reg + step_size_s;
+                        index     <= index + 1;
+
+                        fs_data_valid <= '1';
+                    end if;
+
+
+
+                when work.task.TASK_DONE =>
+                    index        <= 0;
             end case;
         end if;
     end process sync;

software/signal_processing/crc.c

@@ -2,9 +2,38 @@
 #include "system/data_channel.h"
 #include "system/float_word.h"
 
-int task_crc_run( void * task ) {
+#define CRC32_POLY 0xEDB88320
+#define CRC32_INIT 0xFFFFFFFF
+#define DATA_CHANNEL_DEPTH 1024
 
-    // TODO
+static uint32_t crc32_update(uint32_t crc, uint32_t data) {
+    int i;
+    crc ^= data;
+    for (i = 0; i < 32; i++) {
+        if (crc & 1) {
+            crc = (crc >> 1) ^ CRC32_POLY;
+        } else {
+            crc >>= 1;
+        }
+    }
+    return crc;
+}
+
+int task_crc_run(void *task) {
+    crc_config *config = (crc_config *)task;
+    uint32_t source_base = config->base.sources[0];
+    uint32_t sink_base = config->base.sink;
+    uint32_t crc = CRC32_INIT;
+    uint32_t value;
+    
+    for (uint32_t i = 0; i < DATA_CHANNEL_DEPTH; i++) {
+        data_channel_read(source_base, &value);
+        crc = crc32_update(crc, value);
+    }
+    
+    crc ^= 0xFFFFFFFF;
+    
+    data_channel_write(sink_base, crc);
     
     return 0;
 }

software/signal_processing/sine.c

@@ -2,9 +2,26 @@
 #include "system/data_channel.h"
 #include "system/float_word.h"
 
+#include <math.h>
+#include <limits.h>
+
 int task_sine_run( void * data ) {
 
-    // TODO
+    sine_config *task = (sine_config *)data;
+    uint32_t data_channel_base = task->base.sink;
+
+    uint32_t samples_per_period = task->samples_per_periode;
+    float phase = task->phase;
+    float amplitude = task->amplitude;
+
+    float step = ( 2.0f * (float)M_PI ) / (float)samples_per_period;
+
+    for ( uint32_t i = 0; i < 1024; ++i ) {
+        float_word sample;
+        float angle = phase + (float)i * step;
+        sample.value = amplitude * sinf( angle );
+        data_channel_write( data_channel_base, sample.word );
+    }
 
     return 0;
 }

tests/hardware/task_add_sine_cosine/transcript

@@ -0,0 +1,65 @@
+# vsim -voptargs="+acc" -c work.test_task_add_sine_cosine -do "set StdArithNoWarnings 1; set NumericStdNoWarnings 1; run -all" -gCHECK_RESULTS=false 
+# Start time: 11:07:13 on Dec 09,2025
+# ** Note: (vsim-3813) Design is being optimized due to module recompilation...
+# ** Warning: (vopt-10587) Some optimizations are turned off because the +acc switch is in effect. This will cause your simulation to run slowly. Please use -access/-debug to maintain needed visibility.
+# ** Note: (vopt-143) Recognized 2 FSMs in architecture body "add(rtl)".
+# ** Note: (vsim-12126) Error and warning message counts have been restored: Errors=0, Warnings=1.
+# //  Questa Sim-64
+# //  Version 2023.2 linux_x86_64 Apr 11 2023
+# //
+# //  Copyright 1991-2023 Mentor Graphics Corporation
+# //  All Rights Reserved.
+# //
+# //  QuestaSim and its associated documentation contain trade
+# //  secrets and commercial or financial information that are the property of
+# //  Mentor Graphics Corporation and are privileged, confidential,
+# //  and exempt from disclosure under the Freedom of Information Act,
+# //  5 U.S.C. Section 552. Furthermore, this information
+# //  is prohibited from disclosure under the Trade Secrets Act,
+# //  18 U.S.C. Section 1905.
+# //
+# Loading std.standard
+# Loading std.textio(body)
+# Loading ieee.std_logic_1164(body)
+# Loading ieee.numeric_std(body)
+# Loading ieee.fixed_float_types
+# Loading ieee.math_real(body)
+# Loading ieee.fixed_generic_pkg(body)
+# Loading ieee.float_generic_pkg(body)
+# Loading ieee.fixed_pkg
+# Loading ieee.float_pkg
+# Loading work.reg32(body)
+# Loading work.avalon_slave
+# Loading work.test_utility(body)
+# Loading work.test_avalon_slave(body)
+# Loading work.task(body)
+# Loading work.sine_data
+# Loading work.test_hardware_task(body)
+# Loading work.test_data_channel_pkg(body)
+# Loading std.env(body)
+# Loading work.cosine_data
+# Loading work.sine_cosine_data
+# Loading work.test_task_add_sine_cosine(test)#1
+# Loading work.task_add(struct)#1
+# Loading work.hardware_task_control(rtl)#1
+# Loading work.avalon_slave_transitions(rtl)#1
+# Loading work.add(rtl)#1
+# Loading work.float_add(mixed)#1
+# Loading work.data_channel(struct)#1
+# Loading work.data_channel_control(rtl)#1
+# Loading work.avalon_slave_transitions(rtl)#2
+# Loading work.data_sink_mux(rtl)#1
+# Loading work.fifo(rtl)#1
+# Loading work.data_source_mux(rtl)#1
+# set StdArithNoWarnings 1
+# 1
+#  set NumericStdNoWarnings 1
+# 1
+#  run -all
+# --------------------------------------------------------------------------------
+# Starting test_task_add_sine_cosine
+#     test_configure ... [ OK ]
+#     test_execute ... [ OK ]
+#     write_content ... [ OK ]
+# End time: 11:07:14 on Dec 09,2025, Elapsed time: 0:00:01
+# Errors: 0, Warnings: 1

tests/hardware/task_add_sine_cosine/vish_stacktrace.vstf

@@ -0,0 +1,33 @@
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"
+# transcript error: error writing "stdout": broken pipe
+    while executing
+"puts -nonewline stdout $s"

tests/hardware/task_add_sine_cosine/work/_vmake

@@ -0,0 +1,4 @@
+m255
+K4
+z0
+cModel Technology

tests/hardware/task_cosine/transcript

@@ -0,0 +1,65 @@
+# vsim -voptargs="+acc" -c work.test_task_cosine -do "set StdArithNoWarnings 1; set NumericStdNoWarnings 1; run -all" -gCHECK_RESULTS=false 
+# Start time: 10:21:37 on Dec 23,2025
+# ** Note: (vsim-3812) Design is being optimized...
+# ** Warning: (vopt-10587) Some optimizations are turned off because the +acc switch is in effect. This will cause your simulation to run slowly. Please use -access/-debug to maintain needed visibility.
+# ** Note: (vopt-143) Recognized 1 FSM in architecture body "sine(rtl)".
+# ** Note: (vsim-12126) Error and warning message counts have been restored: Errors=0, Warnings=1.
+# //  Questa Sim-64
+# //  Version 2023.2 linux_x86_64 Apr 11 2023
+# //
+# //  Copyright 1991-2023 Mentor Graphics Corporation
+# //  All Rights Reserved.
+# //
+# //  QuestaSim and its associated documentation contain trade
+# //  secrets and commercial or financial information that are the property of
+# //  Mentor Graphics Corporation and are privileged, confidential,
+# //  and exempt from disclosure under the Freedom of Information Act,
+# //  5 U.S.C. Section 552. Furthermore, this information
+# //  is prohibited from disclosure under the Trade Secrets Act,
+# //  18 U.S.C. Section 1905.
+# //
+# Loading std.standard
+# Loading std.textio(body)
+# Loading ieee.std_logic_1164(body)
+# Loading ieee.numeric_std(body)
+# Loading ieee.fixed_float_types
+# Loading ieee.math_real(body)
+# Loading ieee.fixed_generic_pkg(body)
+# Loading ieee.float_generic_pkg(body)
+# Loading ieee.fixed_pkg
+# Loading ieee.float_pkg
+# Loading work.reg32(body)
+# Loading work.avalon_slave
+# Loading work.test_utility(body)
+# Loading work.test_avalon_slave(body)
+# Loading work.task(body)
+# Loading work.cosine_data
+# Loading work.test_hardware_task(body)
+# Loading work.test_data_channel_pkg(body)
+# Loading std.env(body)
+# Loading work.test_task_cosine(test)#1
+# Loading work.float(body)
+# Loading work.task_sine(struct)#1
+# Loading work.hardware_task_control(rtl)#1
+# Loading work.avalon_slave_transitions(rtl)#1
+# Loading work.cordic_pkg(body)
+# Loading work.sine(rtl)#1
+# Loading work.float_sine(rtl)#1
+# Loading work.fixed_sine(rtl)#1
+# Loading work.cordic(rtl)#1
+# Loading work.data_channel(struct)#1
+# Loading work.data_channel_control(rtl)#1
+# Loading work.avalon_slave_transitions(rtl)#2
+# Loading work.data_sink_mux(rtl)#1
+# Loading work.fifo(rtl)#1
+# Loading work.data_source_mux(rtl)#1
+# set StdArithNoWarnings 1
+# 1
+#  set NumericStdNoWarnings 1
+# 1
+#  run -all
+#     test_configure ... [ OK ]
+#     test_execute ... [ OK ]
+#     write_content ... [ OK ]
+# End time: 10:21:38 on Dec 23,2025, Elapsed time: 0:00:01
+# Errors: 0, Warnings: 1

tests/hardware/task_cosine/work/@_opt/VH_HASH_DATA

@@ -0,0 +1,306 @@
+[N
+21
+15
+9 FRAC_BITS
+20
+13 CHECK_RESULTS
+12
+10 ITERATIONS
+8
+12 data_channel
+1
+95 /users/ads1/allamaaki80515/linux/Schreibtisch/signal_processing/tests/hardware/task_cosine/work
+21
+8 GUI_MODE
+3
+3 rtl
+10
+6 cordic
+7
+5 DEPTH
+18
+16 test_task_cosine
+13
+18 RESET_ACTIVE_LEVEL
+2
+24 avalon_slave_transitions
+14
+10 fixed_sine
+11
+4 SIZE
+17
+10 float_sine
+9
+6 struct
+6
+4 fifo
+4
+9 REG_COUNT
+5
+16 REG_ACCESS_TYPES
+16
+9 MAGNITUDE
+19
+4 test
+]
+[G
+1
+14
+3
+1
+11
+1
+0
+32
+0
+0 0
+0
+0
+]
+[G
+1
+18
+19
+1
+20
+0
+0
+0
+0
+0 0
+0
+0
+]
+[G
+1
+2
+3
+1
+5
+0
+0
+0
+0
+6 0
+2
+1
+1
+3
+3
+3
+1
+1
+0 5 1 1
+]
+[G
+1
+2
+3
+2
+5
+0
+0
+0
+0
+7 0
+3
+1
+1
+1
+2
+1
+2
+1
+1
+0 6 1 1
+]
+[G
+1
+14
+3
+1
+16
+0
+0
+0
+0
+8 8
+0
+0
+0
+0
+0
+0
+-16
+63
+0
+0
+]
+[G
+1
+14
+3
+1
+15
+0
+0
+31
+0
+0 0
+0
+0
+]
+[G
+1
+10
+3
+1
+12
+1
+0
+8
+0
+0 0
+0
+0
+]
+[G
+1
+8
+9
+1
+7
+1
+0
+1024
+0
+0 0
+0
+0
+]
+[G
+1
+10
+3
+1
+13
+0
+0
+3
+0
+0 0
+0
+0
+]
+[G
+1
+6
+3
+1
+7
+1
+0
+1024
+0
+0 0
+0
+0
+]
+[G
+1
+2
+3
+1
+4
+1
+0
+6
+0
+0 0
+0
+0
+]
+[G
+1
+2
+3
+2
+4
+1
+0
+7
+0
+0 0
+0
+0
+]
+[G
+1
+10
+3
+1
+11
+1
+0
+32
+0
+0 0
+0
+0
+]
+[G
+1
+14
+3
+1
+12
+1
+0
+8
+0
+0 0
+0
+0
+]
+[G
+1
+14
+3
+1
+13
+0
+0
+3
+0
+0 0
+0
+0
+]
+[G
+1
+18
+19
+1
+21
+0
+0
+0
+0
+0 0
+0
+0
+]
+[G
+1
+17
+3
+1
+12
+0
+0
+8
+0
+0 0
+0
+0
+]