IOBase.h

// -----------------------------------------------------------------------------
#ifndef IOBase_H_
#define IOBase_H_
// -----------------------------------------------------------------------------
#include <string>
#include <memory>
#include "PassiveTimer.h"
#include "Trigger.h"
#include "Mutex.h"
#include "DigitalFilter.h"
#include "Calibration.h"
#include "IOController.h"
#include "SMInterface.h"
// -----------------------------------------------------------------------------
static const int DefaultSubdev  = -1;
static const int DefaultChannel = -1;
static const int NoSafety       = -1;
// -----------------------------------------------------------------------------
struct IOBase
{
    // т.к. IOBase содержит rwmutex с запрещённым конструктором копирования
    // приходится здесь тоже объявлять разрешенными только операции "перемещения"
    IOBase( const IOBase& r ) = delete;
    IOBase& operator=(const IOBase& r) = delete;

    IOBase( IOBase&& r ) = default;
    IOBase& operator=(IOBase&& r) = default;

    ~IOBase();
    IOBase():
        stype(UniversalIO::UnknownIOType),
        cdiagram(nullptr),
        breaklim(0),
        value(0),
        craw(0),
        cprev(0),
        safety(0),
        defval(0),
        df(1),
        nofilter(false),
        f_median(false),
        f_ls(false),
        f_filter_iir(false),
        ignore(false),
        invert(false),
        noprecision(false),
        calcrop(true),
        debounce_pause(false),
        debounce_state(false),
        ondelay_state(false),
        offdelay_state(false),
        d_id(UniSetTypes::DefaultObjectId),
        d_value(1),
        d_off_value(0),
        d_iotype(UniversalIO::UnknownIOType),
        t_ai(UniSetTypes::DefaultObjectId),
        front(false),
        front_type(ftUnknown),
        front_prev_state(false),
        front_state(false),
        rawdata(false)
    {
        si.id = UniSetTypes::DefaultObjectId;
        si.node = UniSetTypes::DefaultObjectId;
        cal.minRaw = cal.maxRaw = cal.minCal = cal.maxCal = cal.precision = 0;
        ti.invert = false;
        ti.hilimit = 0;
        ti.lowlimit = 0;
        ti.id = UniSetTypes::DefaultObjectId;
        ti.state = IONotifyController_i::NormalThreshold;
        ti.tv_sec = 0;
        ti.tv_usec = 0;
    }

    bool check_channel_break( long val );     
    bool check_debounce( bool val );    
    bool check_on_delay( bool val );    
    bool check_off_delay( bool val );   
    bool check_front( bool val );       
    bool check_depend( const std::shared_ptr<SMInterface>& shm ); 
    IOController_i::SensorInfo si;
    UniversalIO::IOType stype;           
    IOController_i::CalibrateInfo cal;   
    Calibration* cdiagram;               
    long breaklim;  
    long value;     
    long craw;      
    long cprev;     
    long safety;    
    long defval;    
    DigitalFilter df;   
    bool nofilter;      
    bool f_median;      
    bool f_ls;          
    bool f_filter_iir;  
    bool ignore;    
    bool invert;    
    bool noprecision;
    bool calcrop;   
    PassiveTimer ptDebounce;    
    PassiveTimer ptOnDelay;     
    PassiveTimer ptOffDelay;    
    Trigger trOnDelay;
    Trigger trOffDelay;
    Trigger trdebounce;

    bool debounce_pause;
    bool debounce_state;    
    bool ondelay_state;     
    bool offdelay_state;    
    // Зависимость (d - depend)
    UniSetTypes::ObjectId d_id;  
    IOController::IOStateList::iterator d_it; 
    long d_value; 
    long d_off_value; 
    UniversalIO::IOType d_iotype;

    // Порог
    UniSetTypes::ObjectId t_ai; 
    IONotifyController_i::ThresholdInfo ti;
    IOController::IOStateList::iterator t_ait; // итератор для аналогового датчика

    // Работа по фронтам сигнала
    enum FrontType
    {
        ftUnknown,
        ft01,      // срабатывание на переход "0-->1"
        ft10       // срабатывание на переход "1-->0"
    };

    friend std::ostream& operator<<( std::ostream& os, const FrontType& f );

    bool front; // флаг работы по фронту
    FrontType front_type;
    bool front_prev_state;
    bool front_state;

    bool rawdata; // флаг для сохранения данный в таком виде в каком они пришли (4байта просто копируются в long). Актуально для Vtypes::F4.

    IOController::IOStateList::iterator ioit;
    UniSetTypes::uniset_rwmutex val_lock;     
    IOBase make_iobase_copy();
    void create_from_iobase( const IOBase& b );

    friend std::ostream& operator<<(std::ostream& os, const IOBase& inf );

    static void processingFasAI( IOBase* it, float new_val, const std::shared_ptr<SMInterface>& shm, bool force );
    static void processingAsAI( IOBase* it, long new_val, const std::shared_ptr<SMInterface>& shm, bool force );
    static void processingAsDI( IOBase* it, bool new_set, const std::shared_ptr<SMInterface>& shm, bool force );
    static long processingAsAO( IOBase* it, const std::shared_ptr<SMInterface>& shm, bool force );
    static float processingFasAO( IOBase* it, const std::shared_ptr<SMInterface>& shm, bool force );
    static bool processingAsDO( IOBase* it, const std::shared_ptr<SMInterface>& shm, bool force );
    static void processingThreshold( IOBase* it, const std::shared_ptr<SMInterface>& shm, bool force );

    static bool initItem( IOBase* b, UniXML::iterator& it, const std::shared_ptr<SMInterface>& shm,
                          const std::string& prefix, bool init_prefix_only,
                          std::shared_ptr<DebugStream> dlog = nullptr, std::string myname = "",
                          int def_filtersize = 0, float def_filterT = 0.0,
                          float def_lsparam = 0.2, float def_iir_coeff_prev = 0.5,
                          float def_iir_coeff_new = 0.5 );


    // helpes
    static std::string initProp( UniXML::iterator& it, const std::string& prop, const std::string& prefix, bool prefonly, const std::string& defval = "" );
    static int initIntProp( UniXML::iterator& it, const std::string& prop, const std::string& prefix, bool prefonly, const int defval = 0 );
    static timeout_t initTimeoutProp( UniXML::iterator& it, const std::string& prop, const std::string& prefix, bool prefonly, const timeout_t defval);
};

// -----------------------------------------------------------------------------
#endif // IOBase_H_
// -----------------------------------------------------------------------------