ct_lib.hpp

Go to the documentation of this file.

/**********************************************************************
    * ct_lib.hpp -- a library of useful processes in the CT MoC       *
    *                                                                 *
    * Authors:  Hosein Attarzadeh (shan2@kth.se)                      *
    *                                                                 *
    * Purpose: Enriching the CT library.                              *
    *                                                                 *
    * Usage:                                                          *
    *                                                                 *
    * License: BSD3                                                   *
    *******************************************************************/

#ifndef CTLIB_H
#define CTLIB_H

#include "ct_moc.hpp"
#include "dde_moc.hpp"
#include "mis.hpp"

namespace ForSyDe
{

namespace CT
{


class sine : public source
{
public:
    sine(sc_module_name name_,      
           const sc_time& endT,     
           const sc_time& period,   
           const CTTYPE& ampl      
           ) : source(name_, [=](CTTYPE& out, const sc_time& t)
                              {
                                  out = ampl*sin(2*M_PI*t/period);
                              }, endT) {}

    std::string forsyde_kind() const {return "CT::sine";}
};


template <class OIf>
inline sine* make_sine(std::string pName,
    const sc_time& endT,  
    const sc_time& period,
    const CTTYPE& ampl,  
    OIf& outS
    )
{
    auto p = new sine(pName.c_str(), endT, period, ampl);

    (*p).oport1(outS);

    return p;
}


class cosine : public source
{
public:
    cosine(sc_module_name name_,      
           const sc_time& endT,       
           const sc_time& period,     
           const CTTYPE& ampl         
           ) : source(name_, [=](CTTYPE& out, const sc_time& t)
                              {
                                  out = ampl*cos(2*M_PI*t/period);
                              }, endT) {}

    std::string forsyde_kind() const {return "CT::cosine";}
};


template <class OIf>
inline cosine* make_cosine(std::string pName,
    const sc_time& endT,  
    const sc_time& period,
    const CTTYPE& ampl,  
    OIf& outS
    )
{
    auto p = new cosine(pName.c_str(), endT, period, ampl);

    (*p).oport1(outS);

    return p;
}


class square : public source
{
public:
    square(sc_module_name name_,      
           const sc_time& endT,       
           const sc_time& period,     
           const CTTYPE& highS,       
           const CTTYPE& lowS,        
           const double& dutyCycle = 0.5
           ) : source(name_, [=](CTTYPE& out, const sc_time& t)
                              {
                                  double tmp = (t/period);
                                  out = tmp-(long)tmp < dutyCycle ? highS : lowS;
                              }, endT) {}

    std::string forsyde_kind() const {return "CT::square";}
};


template <class OIf>
inline square* make_square(std::string pName,
    const sc_time& endT,  
    const sc_time& period,
    const CTTYPE& highS,       
    const CTTYPE& lowS,        
    const double& dutyCycle,   
    OIf& outS
    )
{
    auto p = new square(pName.c_str(), endT, period, highS, lowS, dutyCycle);

    (*p).oport1(outS);

    return p;
}


class scale : public comb
{
public:
    scale(sc_module_name name_,             
           const CTTYPE& scaling_factor    
           ) : comb(name_, [=](CTTYPE& out1, const CTTYPE& inp1)
                             {
                                out1 = scaling_factor * inp1;
                             }) {}

    std::string forsyde_kind() const {return "CT::scale";}
};


template <class OIf, class IIf>
inline scale* make_scale(std::string pName,
    const CTTYPE& scaling_factor,       
    OIf& outS,
    IIf& inpS
    )
{
    auto p = new scale(pName.c_str(), scaling_factor);

    (*p).iport1(inpS);
    (*p).oport1(outS);

    return p;
}


class add : public comb2
{
public:
    add(sc_module_name name_        
        ) : comb2(name_, [=](CTTYPE& out1, const CTTYPE& inp1, const CTTYPE& inp2)
                             {
                                out1 = inp1 + inp2;
                             }) {}

    std::string forsyde_kind() const {return "CT::add";}
};


template <class OIf, class IIf1, class IIf2>
inline add* make_add(std::string pName,
    OIf& outS,
    IIf1& inp1S,
    IIf2& inp2S
    )
{
    auto p = new add(pName.c_str());

    (*p).iport1(inp1S);
    (*p).iport2(inp2S);
    (*p).oport1(outS);

    return p;
}


class sub : public comb2
{
public:
    sub(sc_module_name name_        
        ) : comb2(name_, [=](CTTYPE& out1, const CTTYPE& inp1, const CTTYPE& inp2)
                             {
                                out1 = inp1 - inp2;
                             }) {}

    std::string forsyde_kind() const {return "CT::sub";}
};


template <class OIf, class IIf1, class IIf2>
inline sub* make_sub(std::string pName,
    OIf& outS,
    IIf1& inp1S,
    IIf2& inp2S
    )
{
    auto p = new sub(pName.c_str());

    (*p).iport1(inp1S);
    (*p).iport2(inp2S);
    (*p).oport1(outS);

    return p;
}


class mul : public comb2
{
public:
    mul(sc_module_name name_        
        ) : comb2(name_, [=](CTTYPE& out1, const CTTYPE& inp1, const CTTYPE& inp2)
                             {
                                out1 = inp1 * inp2;
                             }) {}

    std::string forsyde_kind() const {return "CT::mul";}
};


template <class OIf, class IIf1, class IIf2>
inline mul* make_mul(std::string pName,
    OIf& outS,
    IIf1& inp1S,
    IIf2& inp2S
    )
{
    auto p = new mul(pName.c_str());

    (*p).iport1(inp1S);
    (*p).iport2(inp2S);
    (*p).oport1(outS);

    return p;
}


SC_MODULE(gaussian)
{
    CT_out oport1;          

    SY::gaussian gaussian1;
    SY2CT sy2ct1;

    SY::SY2SY<CTTYPE> out_sig;


    gaussian(sc_module_name _name,          
              const double& gaussVar,       
              const double& gaussMean,      
              sc_time sample_period          
          ) : sc_module(_name), gaussian1("gaussian1", gaussVar, gaussMean),
              sy2ct1("sy2ct1", sample_period, HOLD)
    {
        gaussian1.oport1(out_sig);

        sy2ct1.iport1(out_sig);
        sy2ct1.oport1(oport1);
    }
};


template <class OIf>
inline gaussian* make_gaussian(std::string pName,
    const double& gaussVar,       
    const double& gaussMean,      
    const sc_time sample_period,         
    OIf& outS
    )
{
    auto p = new gaussian(pName.c_str(), gaussVar, gaussMean, sample_period);

    (*p).oport1(outS);

    return p;
}


SC_MODULE(filter)
{
    CT_in iport1;           
    CT_out oport1;          

    CT2DDE<CTTYPE> ct2de1;
    DDE::filter<CTTYPE> filter1;
    DDE2CT<CTTYPE> de2ct1;

    DDE::DDE2DDE<CTTYPE> inp_sig, out_sig;
    DDE::DDE2DDE<unsigned int> smp_sig;


    filter(sc_module_name _name,            
           std::vector<CTTYPE> numerators,  
           std::vector<CTTYPE> denominators,
           sc_time sample_period,           
           sc_time min_step=sc_time(0.05,SC_NS),
           double tol_error=1e-5            
          ) : sc_module(_name), ct2de1("ct2de1"),
              filter1("filter1", numerators, denominators, sample_period, min_step, tol_error),
              de2ct1("de2ct1", HOLD)
    {
        ct2de1.iport1(iport1);
        ct2de1.iport2(smp_sig);
        ct2de1.oport1(inp_sig);

        filter1.iport1(inp_sig);
        filter1.oport1(out_sig);
        filter1.oport2(smp_sig);

        de2ct1.iport1(out_sig);
        de2ct1.oport1(oport1);
    }
};


template <class OIf, class I1If>
inline filter* make_filter(std::string pName,
    const std::vector<CTTYPE> numerators,  
    const std::vector<CTTYPE> denominators,
    const sc_time sample_period,            
    OIf& outS,
    I1If& inp1S
    )
{
    auto p = new filter(pName.c_str(), numerators, denominators, sample_period);

    (*p).iport1(inp1S);
    (*p).oport1(outS);

    return p;
}


SC_MODULE(filterf)
{
    CT_in iport1;           
    CT_out oport1;          

    CT2DDEf<CTTYPE> ct2de1;
    DDE::filterf<CTTYPE> filter1;
    DDE2CT<CTTYPE> de2ct1;

    DDE::DDE2DDE<CTTYPE> inp_sig, out_sig;


    filterf(sc_module_name _name,            
           std::vector<CTTYPE> numerators,  
           std::vector<CTTYPE> denominators,
           sc_time sample_period             
          ) : sc_module(_name), ct2de1("ct2de1", sample_period),
              filter1("filter1", numerators, denominators),
              de2ct1("de2ct1", HOLD)
    {
        ct2de1.iport1(iport1);
        ct2de1.oport1(inp_sig);

        filter1.iport1(inp_sig);
        filter1.oport1(out_sig);

        de2ct1.iport1(out_sig);
        de2ct1.oport1(oport1);
    }
};


template <class OIf, class I1If>
inline filterf* make_filterf(std::string pName,
    const std::vector<CTTYPE> numerators,  
    const std::vector<CTTYPE> denominators,
    const sc_time sample_period,            
    OIf& outS,
    I1If& inp1S
    )
{
    auto p = new filterf(pName.c_str(), numerators, denominators, sample_period);

    (*p).iport1(inp1S);
    (*p).oport1(outS);

    return p;
}


template <class OIf, class I1If>
inline filter* make_integrator(std::string pName,
    const sc_time sample_period,            
    OIf& outS,
    I1If& inp1S
    )
{
    std::vector<CTTYPE> numerators = {1.0};
    std::vector<CTTYPE> denominators = {1.0, 0.0};

    auto p = new filter(pName.c_str(), numerators, denominators, sample_period);

    (*p).iport1(inp1S);
    (*p).oport1(outS);

    return p;
}


template <class OIf, class I1If>
inline filterf* make_integratorf(std::string pName,
    const sc_time sample_period,            
    OIf& outS,
    I1If& inp1S
    )
{
    std::vector<CTTYPE> numerators = {1.0};
    std::vector<CTTYPE> denominators = {1.0, 0.0};

    auto p = new filterf(pName.c_str(), numerators, denominators, sample_period);

    (*p).iport1(inp1S);
    (*p).oport1(outS);

    return p;
}


SC_MODULE(pif)
{
    CT_in iport1;           
    CT_out oport1;          

    fanout fanout1;
    scale scale1;
    filterf integrator1;
    add add1;

    signal fan2p, fan2i, p2add, i2add;


    pif(sc_module_name _name,       
           const CTTYPE& kp,        
           const CTTYPE& ki,        
           sc_time sample_period    
          ) : sc_module(_name), fanout1("fanout1"), scale1("scale1", kp),
              integrator1("integrator1", {ki}, {1,0}, sample_period),
              add1("add1")
    {
        fanout1.iport1(iport1);
        fanout1.oport1(fan2p);
        fanout1.oport1(fan2i);

        scale1.iport1(fan2p);
        scale1.oport1(p2add);

        integrator1.iport1(fan2i);
        integrator1.oport1(i2add);

        add1.iport1(p2add);
        add1.iport2(i2add);
        add1.oport1(oport1);
    }
};


template <class OIf, class I1If>
inline pif* make_pif(std::string pName,
    const CTTYPE& kp,
    const CTTYPE& ki,
    const sc_time sample_period,
    OIf& outS,
    I1If& inp1S
    )
{
    auto p = new pif(pName.c_str(), kp, ki, sample_period);

    (*p).iport1(inp1S);
    (*p).oport1(outS);

    return p;
}

}
}
#endif