Connect other HW modules

Author: RMorales25

VirtualPrototype/inc/BusCtrl.h

@@ -23,8 +23,8 @@
 #include "Log.h"
 
 /**
- * Memory mapped Trace peripheral address
- */
+* Memory mapped Trace peripheral address
+*/
 #define TRACE_MEMORY_ADDRESS 0x40000000
 
 #define TIMER_MEMORY_ADDRESS_LO 0x40004000
@@ -72,10 +72,10 @@ class BusCtrl: sc_core::sc_module {
 	tlm_utils::simple_initiator_socket<BusCtrl> timer_socket;
 
 	//Our module's sockets
-	/**
-	 * @brief TLM initiator socket filter module
-	 */
 	tlm_utils::simple_initiator_socket<BusCtrl> filter_socket;
+	tlm_utils::simple_initiator_socket<BusCtrl> sobel_edge_detector_socket;
+	tlm_utils::simple_initiator_socket<BusCtrl> receiver_socket; //VGA AMS socket
+	tlm_utils::simple_initiator_socket<BusCtrl> transmiter_socket; //Ethernet AMS Socket
 
 	/**
 	 * @brief constructor

VirtualPrototype/inc/Memory.h

@@ -61,6 +61,10 @@ class Memory: sc_core::sc_module {
 	// *********************************************
 	virtual unsigned int transport_dbg(tlm::tlm_generic_payload &trans);
 
+	//Backdoor access to memory
+	void backdoor_write(unsigned char*&data, unsigned int data_length, sc_dt::uint64 address);
+	void backdoor_read(unsigned char*&data, unsigned int data_length, sc_dt::uint64 address);
+
 private:
 
 	/**

VirtualPrototype/inc/address_map.hpp

@@ -2,30 +2,73 @@
 #define ADDRESS_MAP_HPP
 
 
-#define CUSTOM_MEMORY_OFFSET 0x40005000
-
-#define FILTER_MEMORY_OFFSET 0x00000003
-#define FILTER_MEMORY_SIZE 36
-#define FILTER_MEMORY_ADDRESS_LO 0x40005003
-#define FILTER_MEMORY_ADDRESS_HI 0x40005027
-
-// #define IMG_FILTER_KERNEL  0x00000003u
-// #define SOBEL_INPUT_0      0x00000027u
-// #define SOBEL_INPUT_1      0x0000002Fu
-// #define SOBEL_OUTPUT       0x00000030u
-// #define IMG_INPUT          0x00000034u
-// #define IMG_INPROCESS_A    0x000E1034u
-// #define IMG_INPROCESS_B    0x0012C034u
-// #define IMG_INPROCESS_C    0x001C2034u
-// #define IMG_COMPRESSED     0x00258034u
-
-// #define IMG_INPUT_SZ       0x000E1000u
-// #define IMG_INPROCESS_A_SZ 0x0004B000u
-// #define IMG_INPROCESS_B_SZ 0x00096000u
-// #define IMG_INPROCESS_C_SZ 0x00096000u
-// #define IMG_COMPRESSED_SZ  0x0004B000u
-
-// #define MEM_START          IMG_INPUT
-// #define MEM_FINISH         IMG_COMPRESSED + IMG_COMPRESSED_SZ
+#define CUSTOM_MEMORY_OFFSET 0x40005000u
+
+//Filter Kernel
+#define IMG_FILTER_KERNEL_OFFSET 0x00000003u
+#define IMG_FILTER_KERNEL_SIZE 36
+#define IMG_FILTER_KERNEL_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_FILTER_KERNEL_OFFSET 
+#define IMG_FILTER_KERNEL_ADDRESS_HI IMG_FILTER_KERNEL_ADDRESS_LO + IMG_FILTER_KERNEL_SIZE
+
+//Filter Output
+#define IMG_FILTER_OUTPUT_OFFSET 0x00000027u
+#define IMG_FILTER_OUTPUT_SIZE 1
+#define IMG_FILTER_OUTPUT_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_FILTER_OUTPUT_OFFSET 
+#define IMG_FILTER_OUTPUT_ADDRESS_HI IMG_FILTER_OUTPUT_ADDRESS_LO + IMG_FILTER_OUTPUT_SIZE
+
+//Sobel Input 0
+#define SOBEL_INPUT_0_OFFSET 0x00000028u
+#define SOBEL_INPUT_0_SIZE 8
+#define SOBEL_INPUT_0_ADDRESS_LO CUSTOM_MEMORY_OFFSET + SOBEL_INPUT_0_OFFSET 
+#define SOBEL_INPUT_0_ADDRESS_HI SOBEL_INPUT_0_ADDRESS_LO + SOBEL_INPUT_0_SIZE
+
+//Sobel Input 1
+#define SOBEL_INPUT_1_OFFSET 0x00000030u
+#define SOBEL_INPUT_1_SIZE 1
+#define SOBEL_INPUT_1_ADDRESS_LO CUSTOM_MEMORY_OFFSET + SOBEL_INPUT_1_OFFSET 
+#define SOBEL_INPUT_1_ADDRESS_HI SOBEL_INPUT_1_ADDRESS_LO + SOBEL_INPUT_1_SIZE
+
+//Sobel Output 1
+#define SOBEL_OUTPUT_OFFSET 0x00000031u
+#define SOBEL_OUTPUT_SIZE 4
+#define SOBEL_OUTPUT_ADDRESS_LO CUSTOM_MEMORY_OFFSET + SOBEL_OUTPUT_OFFSET 
+#define SOBEL_OUTPUT_ADDRESS_HI SOBEL_OUTPUT_ADDRESS_LO + SOBEL_OUTPUT_SIZE
+
+//Img Input
+#define IMG_INPUT_OFFSET 0x00000035u
+#define IMG_INPUT_SIZE 921600
+#define IMG_INPUT_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_INPUT_OFFSET 
+#define IMG_INPUT_ADDRESS_HI IMG_INPUT_ADDRESS_LO + IMG_INPUT_SIZE
+
+//Img In Process A
+#define IMG_INPROCESS_A_OFFSET 0x0000E135u
+#define IMG_INPROCESS_A_SIZE 307200
+#define IMG_INPROCESS_A_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_INPROCESS_A_OFFSET 
+#define IMG_INPROCESS_A_ADDRESS_HI IMG_INPROCESS_A_ADDRESS_LO + IMG_INPROCESS_A_SIZE
+
+//Img In Process B
+#define IMG_INPROCESS_B_OFFSET 0x0012C035u
+#define IMG_INPROCESS_B_SIZE 614400
+#define IMG_INPROCESS_B_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_INPROCESS_B_OFFSET 
+#define IMG_INPROCESS_B_ADDRESS_HI IMG_INPROCESS_B_ADDRESS_LO + IMG_INPROCESS_B_SIZE
+
+//Img In Process C
+#define IMG_INPROCESS_C_OFFSET 0x001C2035u
+#define IMG_INPROCESS_C_SIZE 614400
+#define IMG_INPROCESS_C_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_INPROCESS_C_OFFSET 
+#define IMG_INPROCESS_C_ADDRESS_HI IMG_INPROCESS_C_ADDRESS_LO + IMG_INPROCESS_C_SIZE
+
+//Img Compressed
+#define IMG_COMPRESSED_OFFSET 0x00258035u
+#define IMG_COMPRESSED_SIZE 307200
+#define IMG_COMPRESSED_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_COMPRESSED_OFFSET 
+#define IMG_COMPRESSED_ADDRESS_HI IMG_COMPRESSED_ADDRESS_LO + IMG_COMPRESSED_SIZE
+
+//Img Compressed
+#define IMG_OUTPUT_OFFSET 0x002A3035u
+#define IMG_OUTPUT_SIZE 307200
+#define IMG_OUTPUT_ADDRESS_LO CUSTOM_MEMORY_OFFSET + IMG_OUTPUT_OFFSET 
+#define IMG_OUTPUT_ADDRESS_HI IMG_OUTPUT_ADDRESS_LO + IMG_OUTPUT_SIZE
+
 
 #endif // ADDRESS_MAP_HPP

VirtualPrototype/inc/ips_filter_tlm.hpp

@@ -21,7 +21,7 @@ struct ips_filter_tlm : public Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTE
 
     SC_CTOR(ips_filter_tlm): Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE>(Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE>::name()), img_target(img_target::name()) {
 
-        set_mem_attributes(FILTER_MEMORY_ADDRESS_LO, FILTER_MEMORY_ADDRESS_LO);
+        set_mem_attributes(IMG_FILTER_KERNEL_ADDRESS_LO, IMG_FILTER_KERNEL_ADDRESS_LO);
     }
 
     //Override do_when_transaction functions

VirtualPrototype/inc/sobel_edge_detector_at_model.hpp

@@ -0,0 +1,80 @@
+#ifdef EDGE_DETECTOR_AT_EN
+#ifndef SOBEL_EDGE_DETECTOR_HPP
+#define SOBEL_EDGE_DETECTOR_HPP
+
+#include <systemc.h>
+#include "address_map.hpp"
+
+SC_MODULE(Edge_Detector)
+{
+  
+#ifndef USING_TLM_TB_EN
+  sc_inout<sc_uint<64>> data;
+  sc_in<sc_uint<24>> address;
+#else
+  sc_uint<64> data;
+  sc_uint<24> address;
+#endif // USING_TLM_TB_EN
+  
+  const double delay_full_adder_1_bit = 0.361;
+  const double delay_full_adder = delay_full_adder_1_bit * 16;
+  
+  const double delay_multiplier = 9.82;
+  
+  const sc_int<16> sobelGradientX[3][3] = {{-1,  0,  1},
+                                           {-2,  0,  2},
+                                           {-1,  0,  1}};
+  const sc_int<16> sobelGradientY[3][3] = {{-1, -2, -1},
+                                           { 0,  0,  0},
+                                           { 1,  2,  1}};
+  
+  sc_int<16> localWindow[3][3];
+  
+  sc_int<16> resultSobelGradientX;
+  sc_int<16> resultSobelGradientY;
+  
+  sc_int<16> localMultX[3][3];
+  sc_int<16> localMultY[3][3];
+  
+  sc_event gotLocalWindow;
+  
+  sc_event rd_t, wr_t;
+  
+  sc_event mult_x, mult_y, sum_x, sum_y;
+  
+  SC_CTOR(Edge_Detector)
+  {
+    SC_THREAD(wr);
+    SC_THREAD(rd);
+    SC_THREAD(compute_sobel_gradient_x);
+    SC_THREAD(compute_sobel_gradient_y);
+    SC_THREAD(perform_mult_gradient_x);
+    SC_THREAD(perform_mult_gradient_y);
+    SC_THREAD(perform_sum_gradient_x);
+    SC_THREAD(perform_sum_gradient_y);
+  }
+  
+  virtual void write();
+  
+  virtual void read();
+  
+  void wr();
+  
+  void rd();
+  
+  void compute_sobel_gradient_x();
+  
+  void compute_sobel_gradient_y();
+  
+  void perform_mult_gradient_x();
+  
+  void perform_mult_gradient_y();
+  
+  void perform_sum_gradient_x();
+  
+  void perform_sum_gradient_y();
+  
+};
+
+#endif // SOBEL_EDGE_DETECTOR_HPP
+#endif // EDGE_DETECTOR_AT_EN

VirtualPrototype/src/BusCtrl.cpp

@@ -30,8 +30,6 @@ void BusCtrl::b_transport(tlm::tlm_generic_payload &trans,
 
 	sc_dt::uint64 adr = trans.get_address() / 4;
 
-	
-
 	switch (adr) {
 	case TIMER_MEMORY_ADDRESS_HI / 4:
 	case TIMER_MEMORY_ADDRESS_LO / 4:
@@ -43,10 +41,29 @@ void BusCtrl::b_transport(tlm::tlm_generic_payload &trans,
 		trace_socket->b_transport(trans, delay);
 		break;
 	[[likely]] default:
-		if (FILTER_MEMORY_ADDRESS_LO / 4 <= adr  && adr < FILTER_MEMORY_ADDRESS_HI / 4){
+		if ((IMG_FILTER_KERNEL_ADDRESS_LO / 4 <= adr  && adr < IMG_FILTER_KERNEL_ADDRESS_HI / 4) || 
+		    (IMG_FILTER_OUTPUT_ADDRESS_LO / 4 <= adr  && adr < IMG_FILTER_OUTPUT_ADDRESS_HI / 4))
+		{
 			std::cout << "Writing/Reading to Filter!" << std::endl;
 			filter_socket->b_transport(trans, delay);
 		}
+		else if ((SOBEL_INPUT_0_ADDRESS_LO / 4 <= adr && adr <= SOBEL_INPUT_0_ADDRESS_HI / 4) || 
+		         (SOBEL_INPUT_1_ADDRESS_LO / 4 <= adr && adr <= SOBEL_INPUT_1_ADDRESS_HI / 4) ||
+				 (SOBEL_OUTPUT_ADDRESS_LO / 4 <= adr && adr <= SOBEL_OUTPUT_ADDRESS_HI / 4))
+		{
+			std::cout << "Writing/Reading to Sobel!" << std::endl;
+			sobel_edge_detector_socket->b_transport(trans, delay);
+		}
+		else if ((IMG_INPUT_ADDRESS_LO / 4 <= adr && adr <= IMG_INPUT_ADDRESS_HI / 4))
+		{
+			std::cout << "Writing/Reading to Sobel!" << std::endl;
+			receiver_socket->b_transport(trans, delay);
+		}
+		else if ((IMG_OUTPUT_ADDRESS_LO / 4 <= adr && adr <= IMG_OUTPUT_ADDRESS_HI / 4))
+		{
+			std::cout << "Writing/Reading to Sobel!" << std::endl;
+			transmiter_socket->b_transport(trans, delay);
+		}
 		else {
 			memory_socket->b_transport(trans, delay);
 		}

VirtualPrototype/src/Memory.cpp

@@ -207,3 +207,20 @@ void Memory::readHexFile(std::string const& filename) {
 		SC_REPORT_ERROR("Memory", "Open file error");
 	}
 }
+
+void Memory::backdoor_write(unsigned char*&data, unsigned int data_length, sc_dt::uint64 address)
+{
+  memcpy((mem + address), data, data_length);
+  for (int i = 0; i < 10; i++) {
+  	printf("Backdoor Writing: %0d\n", *(mem + address+i));
+  }
+}
+
+void Memory::backdoor_read(unsigned char*&data, unsigned int data_length, sc_dt::uint64 address)
+{
+  data = new unsigned char[data_length];
+  memcpy(data, (mem + address), data_length);
+  for (int i = 0; i < 10; i++) {
+  	printf("Backdoor Reading: %0d\n", *(mem + address+i));
+  }
+}

VirtualPrototype/src/Simulator.cpp

@@ -16,15 +16,23 @@
 #include <unistd.h>
 #include <chrono>
 
+#include "address_map.hpp"
 #include "CPU.h"
 #include "Memory.h"
 #include "BusCtrl.h"
 #include "Trace.h"
 #include "Timer.h"
 #include "Debug.h"
 
+//For pre-loading images
+#define STB_IMAGE_IMPLEMENTATION
+#include "inc/stb_image.h"
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "inc/stb_image_write.h"
+
 //Our modules
 #include "ips_filter_tlm.hpp"
+#include "sobel_edge_detector_tlm.cpp"
 
 std::string filename;
 bool debug_session = false;
@@ -78,6 +86,8 @@ SC_MODULE(Simulator) {
 		if (debug_session) {
 			Debug debug(cpu, MainMemory);
 		}
+
+		pre_load_memory();
 	}
 
 	~Simulator() {
@@ -87,6 +97,35 @@ SC_MODULE(Simulator) {
 		delete trace;
 		delete timer;
 	}
+
+	void pre_load_memory()
+	{
+		int width, height, channels, pixel_count;
+		unsigned char *noisy_img, *noisy_img2;
+
+		noisy_img = stbi_load("inputs/car_noisy_image.png", &width, &height, &channels, 0);
+		pixel_count = width * height * channels;
+		printf("Pixel Count %0d, Width: %0d, Height: %0d \n", pixel_count, width, height);
+		
+		noisy_img2 = new unsigned char [pixel_count];
+
+		MainMemory->backdoor_write(noisy_img, pixel_count, INPUT_IMG_MEMORY_LO);
+		//stbi_write_png("outputs/car_filtered_image.png", width, height, channels, noisy_img, width*channels);
+	}
+
+	void save_img_from_memory()
+	{
+		int width, height, channels, pixel_count;
+		unsigned char *img_ptr;
+
+		channels = 1;
+		width = 640;
+		height = 452;
+		pixel_count = width * height * channels;
+		MainMemory->backdoor_read(img_ptr, pixel_count, OUTPUT_IMG_MEMORY_LO);
+		
+		stbi_write_png("outputs/car_filtered_image.png", width, height, channels, img_ptr, width*channels);
+	}
 };
 
 Simulator *top;
@@ -179,6 +218,10 @@ int sc_main(int argc, char *argv[]) {
 
 	std::cout << "Total elapsed time: " << elapsed_seconds.count() << "s" << std::endl;
 	std::cout << "Simulated " << int(std::round(instructions)) << " instr/sec" << std::endl;
+	
+	//Generate output image
+	top->save_img_from_memory();
+	
 	std::cout << "Press Enter to finish" << std::endl;
 	std::cin.ignore();
 

VirtualPrototype/src/img_target.cpp

@@ -79,10 +79,10 @@ struct img_target: sc_module
         // Obliged to implement read and write commands
         if (cmd == tlm::TLM_READ_COMMAND) {
             this->do_when_read_transaction(ptr, len, adr);
-            dbgmodprint("Read at address %0x, data: %0x", address_offset, *ptr);
+            //dbgmodprint("Read at address %0x, data: %0x", address_offset, *ptr);
         }
         else if (cmd == tlm::TLM_WRITE_COMMAND) {
-            dbgmodprint("Write at address %0x, data: %0x", address_offset, *ptr);
+            //dbgmodprint("Write at address %0x, data: %0x", address_offset, *ptr);
             this->do_when_write_transaction(ptr, len, adr);
         }