finish isp testbench but still have some errors waiting to be deat with

sim/sc_main.cpp

@@ -13,10 +13,109 @@
 // Include model header, generated from Verilating "isp.v"
 #include "Visp.h"
 
+// Handle file
+#include <fstream>
+#include <iostream>
+
+#define IM_WIDTH 1936
+#define IM_HEIGHT 1088
+#define IM_SIZE (IM_WIDTH * IM_HEIGHT)
+
+using namespace std;
 using namespace sc_core;
 using namespace sc_dt;
 
+SC_MODULE (TB_ISP) {
+    sc_in_clk clk;
+    sc_in<bool> reset;
+    
+    sc_in<bool> data_que;
+    sc_out<bool> data_en;
+    sc_out<uint32_t> data_out[3];
+
+    sc_in<bool> im_clk;
+    sc_in<bool> im_en;
+    sc_in<uint32_t> im_data;
+
+    uint16_t image[IM_HEIGHT][IM_WIDTH];
+    uint32_t out[IM_SIZE] = {0};
+    uint32_t out_head = 0;
+
+    SC_CTOR (TB_ISP) {
+        SC_CTHREAD(send_Data, clk.pos());
+        reset_signal_is(reset, true);
+
+        SC_CTHREAD(read_Data, im_clk.pos());
+    }
+
+    void send_Data(void) {
+        uint16_t pos_x = 0, pos_y = 0;
+        while (true)
+        {
+            if (data_que.read() && pos_y < IM_HEIGHT - 2) {
+                data_en.write(1);
+
+                printf("x=%3d, y=%3d, data=0x%04x\t", pos_x, pos_y, image[pos_y + 0][pos_x]);
+                printf("x=%3d, y=%3d, data=0x%04x\t", pos_x, pos_y, image[pos_y + 1][pos_x]);
+                printf("x=%3d, y=%3d, data=0x%04x\n", pos_x, pos_y, image[pos_y + 2][pos_x]);
+
+                data_out[0].write(image[pos_y + 0][pos_x]);
+                data_out[1].write(image[pos_y + 1][pos_x]);
+                data_out[2].write(image[pos_y + 2][pos_x]);
+
+                if (pos_x++ >= IM_WIDTH) {
+                    pos_x = 0;
+                    pos_y++;
+                }
+            } else {
+                data_en.write(0);
+            }
+
+            wait();
+        }
+        
+    }
+
+    void read_Data(void) {
+        while (true)
+        {
+            if (im_en.read()) {
+                out[out_head++] = im_data.read();
+            }
+
+            wait();
+        }
+    }
+};
+
 int sc_main(int argc, char* argv[]) {
+    // Open image
+    ifstream in_image;
+    ofstream out_image;
+    in_image.open("./Demosaic/sim/transform/test.bin", ios::in | ios::binary);
+    out_image.open("./out.bin", ios::out | ios::binary);
+    if (!in_image.is_open()) {
+        cout << "Open image fail" << endl;
+        exit(0);
+    } else {
+        cout << "Ready to sim" << endl;
+    }
+
+    // Read image
+    uint8_t buf[IM_SIZE * 2] = {0};
+    in_image.read((char*)buf, IM_SIZE * 2);
+    in_image.close();
+    // Reshape data
+    uint16_t image[IM_HEIGHT][IM_WIDTH] = {0};
+    uint32_t i = 0;
+    for (int y = 0; y < IM_HEIGHT; y++) {
+        for (int x = 0; x < IM_WIDTH; x++) {
+            image[y][x] = (uint16_t)buf[i] + ((uint16_t)buf[i + 1] << 8);
+            i++;
+        }
+    }
+    cout << "Finish Reading data" << endl;
+
     // This is a more complicated example, please also see the simpler examples/make_hello_c.
 
     // Create logs/ directory in case we have traces to put under it
@@ -42,31 +141,46 @@ int sc_main(int argc, char* argv[]) {
 
     // Define clocks
     sc_clock clk{"clk", 10, SC_NS, 0.5, 3, SC_NS, true};
-    sc_clock fastclk{"fastclk", 2, SC_NS, 0.5, 2, SC_NS, true};
-
     // Define interconnect
-    sc_signal<bool> reset_l;
-    sc_signal<uint32_t> in_small;
-    sc_signal<uint64_t> in_quad;
-    sc_signal<sc_bv<70>> in_wide;
-    sc_signal<uint32_t> out_small;
-    sc_signal<uint64_t> out_quad;
-    sc_signal<sc_bv<70>> out_wide;
+    sc_signal<bool> reset;
+
+    sc_signal<bool> data_en;
+    sc_signal<bool> data_que;
+    sc_signal<uint32_t> data_in[3];
+
+    sc_signal<bool> out_clk;
+    sc_signal<bool> out_en;
+    sc_signal<uint32_t> data_out;
+
 
     // Construct the Verilated model, from inside Visp.h
     // Using unique_ptr is similar to "Visp* isp = new Visp" then deleting at end
     const std::unique_ptr<Visp> isp{new Visp{"isp"}};
-
     // Attach Visp's signals to this upper model
     isp->clk(clk);
-    isp->fastclk(fastclk);
-    isp->reset_l(reset_l);
-    isp->in_small(in_small);
-    isp->in_quad(in_quad);
-    isp->in_wide(in_wide);
-    isp->out_small(out_small);
-    isp->out_quad(out_quad);
-    isp->out_wide(out_wide);
+    isp->reset(reset);
+    isp->data_en(data_en);
+    isp->data_que(data_que);
+    isp->data_in[0](data_in[0]);
+    isp->data_in[1](data_in[1]);
+    isp->data_in[2](data_in[2]);
+    isp->out_clk(out_clk);
+    isp->out_en(out_en);
+    isp->data_out(data_out);
+
+    // Construct testbench module
+    TB_ISP tb_isp("tb_isp");
+    tb_isp.clk(clk);
+    tb_isp.reset(reset);
+    tb_isp.data_que(data_que);
+    tb_isp.data_en(data_en);
+    tb_isp.data_out[0](data_in[0]);
+    tb_isp.data_out[1](data_in[1]);
+    tb_isp.data_out[2](data_in[2]);
+    tb_isp.im_clk(out_clk);
+    tb_isp.im_en(out_en);
+    tb_isp.im_data(data_out);
+    memcpy(tb_isp.image, image, sizeof(image));
 
     // You must do one evaluation before enabling waves, in order to allow
     // SystemC to interconnect everything for testing.
@@ -91,10 +205,10 @@ int sc_main(int argc, char* argv[]) {
         if (tfp) tfp->flush();
 
         // Apply inputs
-        if (sc_time_stamp() > sc_time(1, SC_NS) && sc_time_stamp() < sc_time(10, SC_NS)) {
-            reset_l = !1;  // Assert reset
+        if (sc_time_stamp() < sc_time(10, SC_NS)) {
+            reset.write(1);  // Assert reset
         } else {
-            reset_l = !0;  // Deassert reset
+            reset.write(0);  // Deassert reset
         }
 
         // Simulate 1ns
@@ -110,11 +224,11 @@ int sc_main(int argc, char* argv[]) {
         tfp = nullptr;
     }
 
-    // Coverage analysis (calling write only after the test is known to pass)
-#if VM_COVERAGE
-    Verilated::mkdir("logs");
-    VerilatedCov::write("logs/coverage.dat");
-#endif
+    // Save output image
+    for (int y = 0; y < IM_HEIGHT; y++)
+        for(int x = 0; x < IM_WIDTH; x++)
+            out_image.write((const char *)&tb_isp.out[y * IM_WIDTH + x], sizeof(tb_isp.out[0]));
+    out_image.close();
 
     // Return good completion status
     return 0;