Test one window mode

Author: RMorales25

HLS/IpsFilterHLS/src/tb_filter.cpp

@@ -297,30 +297,35 @@ int sc_main(int, char*[])
 	sc_argc();
 	sc_argv();
 
-	sc_signal<sc_uint<8> > signal[10];
+	sc_signal<sc_uint<8> > signal;
+  sc_signal<sc_uint<8> > signal_bus[9];
 	sc_clock clk("clk", 1, SC_NS);
 
 	testbench tb_module("tb_module");
 	Filter filter("filter");
 
 	filter.clk(clk);
-	filter.input_window_0(signal[0]);
-	filter.input_window_1(signal[1]);
-	filter.input_window_2(signal[2]);
-	filter.input_window_3(signal[3]);
-	filter.input_window_4(signal[4]);
-	filter.input_window_5(signal[5]);
-	filter.input_window_6(signal[6]);
-	filter.input_window_7(signal[7]);
-	filter.input_window_8(signal[8]);
+	filter.input_window_0(signal_bus[0]);
+	filter.input_window_1(signal_bus[1]);
+	filter.input_window_2(signal_bus[2]);
+	filter.input_window_3(signal_bus[3]);
+	filter.input_window_4(signal_bus[4]);
+	filter.input_window_5(signal_bus[5]);
+	filter.input_window_6(signal_bus[6]);
+	filter.input_window_7(signal_bus[7]);
+	filter.input_window_8(signal_bus[8]);
 
 	for (int i = 0; i < 9; i++){
-		tb_module.img_window[i](signal[i]);
+		tb_module.img_window[i](signal_bus[i]);
 	}
-	filter.output(signal[9]);
-	tb_module.mean(signal[9]);
+	filter.output(signal);
+	tb_module.mean(signal);
 
 	sc_start();
+#ifdef IPS_DEBUG_EN
+	std::cout << "Test starting" << std::endl;
+	std::cout << "@" << sc_time_stamp() << std::endl;
+#endif // IPS_DEBUG_EN
 
 
 //  printf(" Signal is %0u\n", signal.read());

HLS/IpsFilterHLS/src/tb_module.cpp

@@ -1,25 +1,85 @@
 #include <systemc.h>
+#include <cstdlib>
+
+#define IPS_FILTER_KERNEL_SIZE 3
+#define DELAY_TIME (IPS_FILTER_KERNEL_SIZE * IPS_FILTER_KERNEL_SIZE * 1) + 4 + 2 + 1
 
 SC_MODULE (testbench) {
-	sc_out<sc_uint<8> > img_window[9];
+	sc_out<sc_uint<8> > img_window[IPS_FILTER_KERNEL_SIZE*IPS_FILTER_KERNEL_SIZE];
 	sc_in<sc_uint<8> > mean;
 
 	SC_CTOR (testbench) {
 		SC_THREAD(process);
 	}
 
 	void process() {
-		for (int i = 0; i < 9; i++){
-			img_window[i] = 0;
+
+#ifdef TEST_MODE_ONE_WINDOW
+		run_one_window();
+#endif //TEST_MODE_ONE_WINDOW
+		sc_stop();
+	}
+
+#ifdef TEST_MODE_ONE_WINDOW
+	void run_one_window()
+	{
+		sc_uint<8> local_window[IPS_FILTER_KERNEL_SIZE * IPS_FILTER_KERNEL_SIZE];
+		sc_uint<8>  result;
+
+		#ifdef IPS_DEBUG_EN
+		#ifdef TEST_MODE_ONE_WINDOW_RANDOM
+		SC_REPORT_INFO("TEST_MODE_ONE_WINDOW_NORMAL", "Running test");
+		#elif defined(TEST_MODE_ONE_WINDOW_NORMAL)
+		SC_REPORT_INFO("TEST_MODE_ONE_WINDOW_NORMAL", "Running test");
+		#else
+		SC_REPORT_INFO("TEST_MODE_ONE_WINDOW_DEFAULT", "Running test");
+		#endif // TEST_MODE_ONE_WINDOW_RANDOM
+		SC_REPORT_INFO("Initialize window", "Window value");
+		#endif // IPS_DEBUG_EN
+
+		// Initialize image window
+		for (int i = 0; i < IPS_FILTER_KERNEL_SIZE; i++)
+		{
+			for (int j = 0; j < IPS_FILTER_KERNEL_SIZE; j++)
+			{
+       			sc_uint<8>  value;
+				
+#ifdef TEST_MODE_ONE_WINDOW_RANDOM
+       			value = (sc_uint<8> ) (rand() % 256);
+#elif defined(TEST_MODE_ONE_WINDOW_NORMAL)
+       			value = (sc_uint<8> ) (i * IPS_FILTER_KERNEL_SIZE + j);
+#else
+       			value = (sc_uint<8> ) i;
+#endif // TEST_MODE_ONE_WINDOW
+
+				local_window[i * IPS_FILTER_KERNEL_SIZE + j] = value;
+#ifdef IPS_DEBUG_EN
+				std::cout << "[" << (int) local_window[i * IPS_FILTER_KERNEL_SIZE + j] << "]";
+#endif // IPS_DUMP_EN
+			}
+			
+#ifdef IPS_DEBUG_EN
+				std::cout << std::endl;
+#endif // IPS_DEBUG_EN	
 		}
-		wait(10, SC_NS);
-		std::cout << "Result: " << mean << std::endl;
-		std::cout << "HERE" << std::endl;
-		for (int i = 0; i < 9; i++){
-			img_window[i] = i;
+
+		for (int i = 0; i < IPS_FILTER_KERNEL_SIZE*IPS_FILTER_KERNEL_SIZE; i++) {
+#ifdef IPS_DEBUG_EN
+			SC_REPORT_INFO("[DEBUG]", "Writing to image window port the value:");
+			std::cout << "Iteration: " << i << " local_window = " << local_window[i] << std::endl;
+#endif // IPS_DEBUG_EN
+			img_window[i].write(local_window[i]); //Write to port
 		}
-		wait(10, SC_NS);
-		std::cout << "Result: " << mean << std::endl;
-		sc_stop();
+
+		wait(DELAY_TIME + 10, SC_NS);
+		result = mean.read();
+
+#ifdef IPS_DEBUG_EN
+		SC_REPORT_INFO("TEST_MODE_ONE_WINDOW", "filtering");
+		std::cout << "Result = " << result << std::endl;
+#endif // IPS_DEBUG_E
+
+		//delete [] img_window;
 	}
+	#endif //TEST_MODE_ONE_WINDOW
 };