Add VGA module to Virtual Prototype

Author: jgavillalobos

modules/VirtualPrototype/FreeRTOS/freertos_test.c

@@ -415,30 +415,58 @@ void save_image_from_mem(int image_id)
 	printf("Saved image with id %0d\n", image_id);
 }
 
+void receive_image()
+{
+	unsigned char *start_reception = (unsigned char *) IMG_INPUT_START_ADDRESS_LO;
+	unsigned char *receive_status = (unsigned char *) IMG_INPUT_DONE_ADDRESS_LO;
+	unsigned char receive_status_result;
+
+	const TickType_t xDelay = 200;
+
+	printf("Preparing to receive image from VGA\n");
+
+	*start_reception = 1;
+
+	printf("Sent start signal to receiver\n");
+
+	memcpy(&receive_status_result, receive_status, sizeof(char));
+	while(receive_status_result == 0)
+	{
+		printf("\tReceiver still receiving data\n");
+		vTaskDelay(xDelay);
+		memcpy(&receive_status_result, receive_status, sizeof(char));
+	}
+	printf("Receive process finished in the receiver\n");
+}
+
 static void testbench(void *pParameter) {
+	receive_image();
+
+	save_image_from_mem(0);
+
 	convert_to_grayscale();
 
 	save_image_from_mem(1);
 
-	filter_image();
+	// filter_image();
 
-	save_image_from_mem(2);
+	// save_image_from_mem(2);
 
-	obtain_gradients_sobel();
+	// obtain_gradients_sobel();
 
-	save_image_from_mem(3);
+	// save_image_from_mem(3);
 
-	unificate_img();
+	// unificate_img();
 
-	save_image_from_mem(4);
+	// save_image_from_mem(4);
 
-	copy_data();
+	// copy_data();
 
-	save_image_from_mem(5);
+	// save_image_from_mem(5);
 
-	transmit_data(IMAG_ROWS * IMAG_COLS);
+	// transmit_data(IMAG_ROWS * IMAG_COLS);
 
-	save_image_from_mem(6);
+	// save_image_from_mem(6);
 }
 
 int main( void )

modules/VirtualPrototype/include/important_defines.hpp

@@ -16,4 +16,44 @@
 #define IPS_OUT_TYPE_TB float
 #endif // IPS_OUT_TYPE_TB
 
+// VGA settings
+#ifndef IPS_H_ACTIVE
+#define IPS_H_ACTIVE 640
+#endif // IPS_H_ACTIVE
+#ifndef IPS_H_FP
+#define IPS_H_FP 16
+#endif // IPS_H_FP
+#ifndef IPS_H_SYNC_PULSE
+#define IPS_H_SYNC_PULSE 96
+#endif // IPS_H_SYNC_PULSE
+#ifndef IPS_H_BP
+#define IPS_H_BP 48
+#endif // IPS_H_BP
+#ifndef IPS_V_ACTIVE
+#define IPS_V_ACTIVE 480
+#endif // IPS_V_ACTIVE
+#ifndef IPS_V_FP
+#define IPS_V_FP 10
+#endif // IPS_V_FP
+#ifndef IPS_V_SYNC_PULSE
+#define IPS_V_SYNC_PULSE 2
+#endif // IPS_V_SYNC_PULSE
+#ifndef IPS_V_BP
+#define IPS_V_BP 33
+#endif // IPS_V_BP
+// Compute the total number of pixels
+#define IPS_TOTAL_VERTICAL (IPS_H_ACTIVE + IPS_H_FP + IPS_H_SYNC_PULSE + IPS_H_BP)
+#define IPS_TOTAL_HORIZONTAL (IPS_V_ACTIVE + IPS_V_FP + IPS_V_SYNC_PULSE + IPS_V_BP)
+#define IPS_TOTAL_PIXELES (IPS_TOTAL_VERTICAL * IPS_TOTAL_HORIZONTAL)
+// Number of bits for ADC, DAC and VGA
+#ifndef IPS_BITS
+#define IPS_BITS 8
+#endif // IPS_BITS
+#ifndef IPS_VOLTAGE_MIN
+#define IPS_VOLTAGE_MIN 0
+#endif // IPS_VOLTAGE_MIN
+#ifndef IPS_VOLTAGE_MAX
+#define IPS_VOLTAGE_MAX 3300
+#endif // IPS_VOLTAGE_MAX
+
 #endif // IMPORTANT_DEFINES_HPP

modules/VirtualPrototype/include/seq_item_vga.hpp

@@ -0,0 +1,139 @@
+#ifndef IPS_SEQ_ITEM_VGA_HPP
+#define IPS_SEQ_ITEM_VGA_HPP
+
+#define int64 systemc_int64
+#define uint64 systemc_uint64
+#include <systemc.h>
+#include <systemc-ams.h>
+#undef int64
+#undef uint64
+#define int64 opencv_int64
+#define uint64 opencv_uint64
+#include <opencv2/opencv.hpp>
+#undef int64
+#undef uint64
+
+#include "vunit.hpp"
+
+// Image path
+#define IPS_IMG_PATH_TB "../../tools/datagen/src/imgs/car_rgb_noisy_image.jpg"
+
+/**
+ * @brief This class is used to generate the data for the AMS test
+ *
+ * @tparam BITS - the number of output bits of the digital pixel
+ * @tparam H_ACTIVE - output horizontal active video pixels
+ * @tparam H_FP - wait after the display period before the sync
+ *  horizontal pulse
+ * @tparam H_SYNC_PULSE - assert HSYNC
+ * @tparam H_BP - wait after the sync horizontal pulse before starting
+ *  the next display period
+ * @tparam V_ACTIVE - output vertical active video pixels
+ * @tparam V_FP - wait after the display period before the sync
+ *  vertical pulse
+ * @tparam V_SYNC_PULSE - assert VSYNC
+ * @tparam V_BP - wait after the sync vertical pulse before starting
+ *  the next display period
+ */
+template <
+    unsigned int BITS = 8,
+    unsigned int H_ACTIVE = 640,
+    unsigned int H_FP = 16,
+    unsigned int H_SYNC_PULSE = 96,
+    unsigned int H_BP = 48,
+    unsigned int V_ACTIVE = 480,
+    unsigned int V_FP = 10,
+    unsigned int V_SYNC_PULSE = 2,
+    unsigned int V_BP = 33,
+    int VMIN = 0,
+    int VMAX = 5,
+    VUnit VU = VUnit::v>
+SCA_TDF_MODULE(seq_item_vga)
+{
+protected:
+  cv::Mat tx_img;
+  // Min voltage value based on the voltage units
+  const double V_MIN = static_cast<double>(VMIN) / static_cast<double>(VU);
+  // Max voltage value based on the voltage units
+  const double V_MAX = static_cast<double>(VMAX) / static_cast<double>(VU);
+  // Max digital output code
+  const double MAX_DIG = static_cast<double>((1 << BITS) - 1);
+
+public:
+  // Counters
+  sca_tdf::sca_de::sca_in<unsigned int> hcount;
+  sca_tdf::sca_de::sca_in<unsigned int> vcount;
+  // Output pixel
+  sca_tdf::sca_out<double> o_red;
+  sca_tdf::sca_out<double> o_green;
+  sca_tdf::sca_out<double> o_blue;
+
+  SC_CTOR(seq_item_vga)
+  {
+    // Read image
+    const std::string img_path = IPS_IMG_PATH_TB;
+
+    cv::Mat read_img = cv::imread(img_path, cv::IMREAD_COLOR);
+
+    // CV_8UC3 Type: 8-bit unsigned, 3 channels (e.g., for a color image)
+    read_img.convertTo(this->tx_img, CV_8UC3);
+
+    // Check if the image is loaded successfully
+    if (this->tx_img.empty())
+    {
+      std::cerr << "Error: Could not open or find the image!" << std::endl;
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  void set_attributes()
+  {
+    // Propagation time from input to output
+    set_timestep(sca_core::sca_time(1, sc_core::SC_NS));
+    this->o_red.set_delay(17);
+    this->o_green.set_delay(17);
+    this->o_blue.set_delay(17);
+  }
+
+  void processing()
+  {
+    const int IMG_ROW = static_cast<int>(this->vcount.read()) - (V_SYNC_PULSE + V_BP);
+    const int IMG_COL = static_cast<int>(this->hcount.read()) - (H_SYNC_PULSE + H_BP);
+
+    if ((IMG_ROW < 0) || (IMG_COL < 0) || (IMG_ROW >= static_cast<int>(V_ACTIVE)) || (IMG_COL >= static_cast<int>(H_ACTIVE)))
+    {
+      this->o_red.write(0.0);
+      this->o_green.write(0.0);
+      this->o_blue.write(0.0);
+    }
+    else
+    {
+      if ((IMG_ROW >= this->tx_img.rows) || (IMG_COL >= this->tx_img.cols))
+      {
+        this->o_red.write(0.0);
+        this->o_green.write(0.0);
+        this->o_blue.write(0.0);
+      }
+      else
+      {
+        cv::Vec3b pixel = tx_img.at<cv::Vec3b>(IMG_ROW, IMG_COL, 0);
+
+        this->o_red.write(sc_uint2double(static_cast<sc_uint<BITS>>(pixel[0])));
+        this->o_green.write(sc_uint2double(static_cast<sc_uint<BITS>>(pixel[1])));
+        this->o_blue.write(sc_uint2double(static_cast<sc_uint<BITS>>(pixel[2])));
+      }
+    }
+  }
+
+  /**
+   * @brief Convert the digital signal into analog signal
+   * The N-bit digital code is converted into an analog signal in a voltage
+   * range from Vmin to Vmax
+   */
+  double sc_uint2double(sc_uint<BITS> in)
+  {
+    double dig_in = static_cast<double>(in);
+    return V_MIN + (dig_in / MAX_DIG) * (V_MAX - V_MIN);
+  }
+};
+#endif // IPS_SEQ_ITEM_VGA_HPP

modules/VirtualPrototype/include/vga_tlm.hpp

@@ -0,0 +1,51 @@
+#ifndef IPS_VGA_TLM_HPP
+#define IPS_VGA_TLM_HPP
+#include <systemc.h>
+using namespace sc_core;
+using namespace sc_dt;
+using namespace std;
+
+#include <tlm.h>
+#include <tlm_utils/simple_initiator_socket.h>
+#include <tlm_utils/simple_target_socket.h>
+#include <tlm_utils/peq_with_cb_and_phase.h>
+
+#include "common_func.hpp"
+#include "important_defines.hpp"
+#include "vga.hpp"
+#include "../src/img_target.cpp"
+
+// Extended Unification TLM
+struct vga_tlm
+  : public vga<
+      IPS_BITS,
+      IPS_H_ACTIVE, IPS_H_FP, IPS_H_SYNC_PULSE, IPS_H_BP,
+      IPS_V_ACTIVE, IPS_V_FP, IPS_V_SYNC_PULSE, IPS_V_BP
+    >, public img_target
+{
+protected:
+  unsigned char* tmp_img;
+public:
+  vga_tlm(sc_module_name name, bool use_prints_)
+    : vga<
+      IPS_BITS,
+      IPS_H_ACTIVE, IPS_H_FP, IPS_H_SYNC_PULSE, IPS_H_BP,
+      IPS_V_ACTIVE, IPS_V_FP, IPS_V_SYNC_PULSE, IPS_V_BP>((std::string(name) + "_HW_block").c_str()),
+      img_target((std::string(name) + "_target").c_str())
+  {
+      this->use_prints = use_prints_;
+      checkprintenableimgtar(use_prints);
+      set_mem_attributes(IMG_INPUT_ADDRESS_LO, IMG_INPUT_SIZE+IMG_INPUT_START_SIZE+IMG_INPUT_DONE_SIZE);
+  }
+
+  // Override do_when_transaction functions
+  virtual void do_when_read_transaction(unsigned char *&data, unsigned int data_length, sc_dt::uint64 address);
+  virtual void do_when_write_transaction(unsigned char *&data, unsigned int data_length, sc_dt::uint64 address);
+
+  //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);
+
+  unsigned char *return_mem_ptr();
+};
+#endif // IPS_VGA_TLM_HPP

modules/VirtualPrototype/src/BusCtrl.cpp

@@ -58,7 +58,9 @@ void BusCtrl::b_transport(tlm::tlm_generic_payload &trans,
 			dbgmodprint(use_prints, "Writing/Reading to Sobel!");
 			sobel_edge_detector_socket->b_transport(trans, delay);
 		}
-		else if ((IMG_INPUT_ADDRESS_LO / 4 <= adr && adr < IMG_INPUT_ADDRESS_HI / 4))
+		else if ((IMG_INPUT_ADDRESS_LO / 4 <= adr && adr < IMG_INPUT_ADDRESS_HI / 4) ||
+						 (IMG_INPUT_START_ADDRESS_LO / 4 <= adr && adr < IMG_INPUT_START_ADDRESS_HI / 4) ||
+						 (IMG_INPUT_DONE_ADDRESS_LO / 4 <= adr && adr < IMG_INPUT_DONE_ADDRESS_HI / 4))
 		{
 			dbgmodprint(use_prints, "Writing/Reading to Receiver!");
 			receiver_socket->b_transport(trans, delay);