Ошибка: нет совпадения для вызова "модуля"

Question

Я не могу инициализировать или позвонить full_adder модуль для объединения нескольких full_adder,

Getting error 
error: no match for call to ‘(full_adder) (sc_core::sc_signal_in_if<sc_dt::sc_uint<4> >*, sc_core::sc_signal_in_if<sc_dt::sc_uint<4> >*, sc_core::sc_signal<bool, (sc_core::sc_writer_policy)0u>&, sc_core::sc_signal_inout_if<sc_dt::sc_uint<4> >*, sc_core::sc_signal<bool, (sc_core::sc_writer_policy)0u>&)’
  (*fa0_ptr) (a[0],b[0], c0,sum[0],c0);

помощь очень ценится.

Вот мой пример кода.

full_adder.h

SC_MODULE(full_adder)
{
        sc_in<bool> a,b, carry_in;
        sc_out<bool> sum, carry_out;

        sc_signal<bool> c1,s1,c2;
        void prc_or();
contd.......

fourbit_adder.h

#include "full_adder.h"

SC_MODULE(fourbit_adder)
{
        sc_in<sc_uint<4> > a,b;
        sc_in<bool> carry_in;
        sc_out<sc_uint<4> > sum;
        sc_out<bool> carry_out;



        sc_signal<bool> c0,c1,c2;
        void prc_or();
        full_adder *fa0_ptr, *fa1_ptr, *fa2_ptr, *fa3_ptr;

        SC_CTOR(fourbit_adder)
        {

        fa0_ptr = new full_adder("fa0"); // constructor operator which allocates and initialize the memory.
        //Positional association
        (*fa0_ptr) (a[0],b[0], c0,sum[0],c0);

Answer 1

Во-первых, да, вы можете бросить int в bool но это не совсем ваша проблема. Вы пытаетесь соединить сигналы и порты (или интерфейсы и каналы) вместе. И хотя каналы несут int а также boolсами каналы имеют совершенно разные типы (например, sc_in<bool> а также sc_signal< sc_int<99> > несовместимых типов).

Самое простое решение - просто использовать промежуточный модуль для преобразования сигналов. То есть тот, который занимает sc_int<W> и преобразует его в массив W логических сигналов (или наоборот). Я думаю, что вы можете искать это sc_int_bitref класс, который может ссылаться немного с sc_int или же sc_uint,

Вот быстрый, но полностью рабочий пример. Шаблон класса UintToBits модуль имеет один сигнал типа sc_uint и массив bool сигналы. Процесс модуля чувствителен к sc_uint сигнал и обновляет все bool сигналы при срабатывании. Вы можете довести это до n-й степени с помощью шаблонов классов (sc_int/sc_uint/sc_lv и т.д.) но это просто простое решение, которое должно заставить вас работать.

шаблон SC_MODULE (UintToBits) {

typedef sc_uint<W>  UintType;   //type of sc_uint
sc_signal<UintType> uint_i;     //input signal sc_uint
sc_signal<bool>     bool_o[W];  //output signal W x bool

SC_CTOR(UintToBits){
    SC_METHOD(proc);        //setup conversion proc
    sensitive << uint_i;    //and kick it off when uint changes
}

void proc(){
    UintType value = uint_i;    //get the uint value
    for(int i = 0; i < W; ++i){ //for each bit in uint
        bool_o[i] = value[i];   //bool o/p sc_int_bitref[i]
    }
}

};

Для демонстрации предположим, что у нас есть класс ниже, который принимает один бит ввода.

// Некоторый случайный модуль принимает один битовый вход SC_MODULE (ModuleBit) {

sc_in_clk clk_i;        //just to make it go
sc_in<bool> bool_i;     //bit input

SC_CTOR(ModuleBit){
    SC_METHOD(proc);    //a proc just to print out the bit
    sensitive << clk_i.pos();
    dont_initialize();
}

void proc(){ cout << bool_i; }  

};

И этот блок, который выводит sc_uint

// Какой-то случайный модуль с данными sc_uint SC_MODULE (ModuleBitsW) {

sc_in_clk clk_i;            //just to make it go
sc_out<UintType> uint_o;    //the sc_uint

SC_CTOR(ModuleBitsW){
    SC_METHOD(proc);        //proc just to change the output
    sensitive << clk_i.pos();
    uint_o.initialize(0);
    dont_initialize();
}

void proc(){
    uint_o = uint_o->read() + 1;    //output current value + 1
    cout << '\n'; //emit nl to make seperate bool modules o/ps
}

};

Затем мы можем соединить их вместе с помощью модуля промежуточного преобразователя.

int sc_main (int, char **) {

const int W = 4; //Assume we have 4 bits
typedef UintToBits<W>::UintType UintType;


sc_clock clock("clock", 1.0, SC_SEC);   //randomly chosen one second period clock 

//create the sc_uint module, the bool modules and the converter module
UintToBits<W> convert("convert");   //converts sc_uint signal to W x bool signals
ModuleBitsW bitsw_m("bitsw_m");     //module with sc_uint output
ModuleBit* bit_m[W];                //W x modules needing single bit input

//connect the single bit modules
for(int i = 0; i < W; ++i){
    bit_m[i] = new ModuleBit(("m" + to_string(i)).c_str());
    bit_m[i]->bool_i(convert.bool_o[W-i-1]);    //reverse them to print 'normally' (not guaranteed)
    bit_m[i]->clk_i(clock);
}
bitsw_m.uint_o(convert.uint_i); //connect output of sc_uint module to converter module
bitsw_m.clk_i(clock);           //just to drive it


sc_start(20.0, SC_SEC);     //run it for 20 cycles and see what we get
return 0;

// пусть процесс очищает память, я слишком ленивый}

Который, когда я побежал, он дал вывод 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 0000 0001 0010 0011

Я использовал это включает в себя <systemc>, <iostream> и импортировал эти пространства имен sc_core, sc_dt, std и составлено с g++ -std=c++11 FullAdder.cpp -lsystemc с gcc 4.9.2` на linux64

Это должно решить вашу проблему на данный момент, но если вы планируете делать много последовательных параллельных преобразований, это может стоить вам при разработке небольшого набора шаблонов (или, более вероятно, классов шаблонов-шаблонов). И, наконец, не забывайте, что очень полезно sc_int_bitref вернулся из sc_int[] оператор, но вам нужен сигнал (не только bool или же int) получать уведомления об изменениях для управления процессами.

Answer 2

Вы проходите sum[0] в качестве 4-го аргумента в (*fa0_ptr) (a[0],b[0], c0,sum[0],c0) который имеет тип sc_uint но 4-й член full_adder имеет тип bool,