Port not bound SystemC (E112)

Question

I am trying to implement a producer (master) speaking to a memory element (slave) through the memory controller (which implements the interface simple_mem_interface). Note: Some functions details and include statements are not fully mentioned in the code attached.

Searching for bugs in the code. Adding debugging tools to find the fault in Write Enable Port.

binding.cpp

int sc_main(int argc, char* argv[])
{

sc_signal<unsigned int> d_out,d_in,address_d;
sc_signal<bool> wen, ren, ack;

sc_clock ClkFast("ClkFast", 100, SC_NS);
sc_clock ClkSlow("ClkSlow", 50, SC_NS);

Memory_Controller Controller1 ("Controller");
d_out = Controller1.data_mem_read;
ren.write(Controller1.REN);
ack.write(Controller1.ack);
d_in.write(Controller1.data_write);
address_d.write(Controller1.address);
wen.write(Controller1.WEN);


producer P1("Producer");
P1.out(Controller1);
P1.Clk(ClkFast);

Memory_module MEM("Memory");
MEM.Wen(wen);
MEM.Ren(ren);
MEM.ack(ack);
MEM.Clock(ClkSlow);
MEM.data_in(d_in);
MEM.data_out(d_out);
MEM.address(address_d);

sc_start(5000, SC_NS);

return 0;

Memory_controller.h

#define MEM_SIZE 100
#include <interface_func.h>
class Memory_Controller :  public sc_module, public simple_mem_if
{
public:
// Ports
sc_in <unsigned int> data_mem_read{ "Data_Read_from_Memory" };
sc_out<bool> REN { "Read_Enable" };
sc_out<bool> WEN { "Write_Enable" };
sc_out <bool> ack{ "ACK_Bool" };
sc_out<unsigned int> address{ "Memory_Address" }, data_write{ 
"Data_Written_to_Memory" };

// constructor
Memory_Controller(sc_module_name nm) : sc_module(nm)
{ // Creating a 2 dimentional array holding adresses and data
    WEN.write(false);
    REN.write(false);
    ack.write(false);
}
~Memory_Controller() //destructor
{

}

bool Write(unsigned int address_i, unsigned int datum)        // blocking write
{
    WEN.write(true);
    REN.write(false);
    data_write.write(datum);
    address.write(address_i);
    if (ack == true)
        return true;
    else
        return false;
}
bool Read(unsigned int address_i, unsigned int& datum_i)        // blocking read
{
    WEN.write(false);
    REN.write(true);
    datum_i=data_mem_read;
    address.write(address_i);
    if (ack == true)
        return true;
    else
        return false;
}

void register_port(sc_port_base& port, const char* if_typename)
{
    cout << "binding    " << port.name() << " to "
        << "interface: " << if_typename << endl;
}
};

Memory.h

#define MEM_SIZE 100
#include "interface_func.h"
class Memory_module : public sc_module
{
public:
sc_in<bool> Wen,Ren;
sc_in <unsigned int> address, data_in ;
sc_in<bool> Clock;
sc_out <unsigned int> data_out;
sc_out <bool> ack;

bool fileinput = false;
ifstream myfile;
unsigned int item [MEM_SIZE];
Memory_module()
{
}



void Write()        // blocking write
{
    while (true)
    {
        wait();
        if (Wen==true)
        {   
            if (address >= MEM_SIZE || address < 0)
            {
                ack=false;
            }
            else
            {
                item[address]=data_in;
                ack=true;
            }
        }
    }
}

void Read()        // blocking read
{
    while (true)
    {
        wait();
        if (Ren)
        {
            if (address >= MEM_SIZE || address < 0)
                ack=false;
            else
            {
                data_out.write(item[address]);
                ack=true;
            }


        }
    }

}

SC_CTOR(Memory_module)
{
    SC_THREAD(Read);
    sensitive << Clock.pos();
    SC_THREAD(Write);
    sensitive << Clock.pos();
}
};

interface_func.h

class simple_mem_if : virtual public sc_interface
{
public:
virtual bool Write(unsigned int addr, unsigned int data) = 0;
virtual bool Read(unsigned int addr, unsigned int& data) = 0;
};

After debugging the SystemC binder.cpp code, the following error arises: (E112) get interface failed: port is not bound : port 'Controller.Write_Enable' (sc_out)

Answer 1

You cannot drive your unconnected ports in the Memory_Controller constructor. If you want to explicitly drive these ports during startup, move these calls to a start_of_simulation callback:

Memory_Controller(sc_module_name nm) : sc_module(nm)
{}

void start_of_simulation()
{
    WEN.write(false);
    REN.write(false);
    ack.write(false);
}