IOBase.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// -----------------------------------------------------------------------------
#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"
// -------------------------------------------------------------------------
namespace uniset
{
    // -----------------------------------------------------------------------------
    struct IOBase
    {
        static const int DefaultSubdev  = -1;
        static const int DefaultChannel = -1;
        static const int DefaultCard = -1;
 
        // т.к. 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),
            safeval(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(uniset::DefaultObjectId),
            d_value(1),
            d_off_value(0),
            d_iotype(UniversalIO::UnknownIOType),
            t_ai(uniset::DefaultObjectId),
            front(false),
            front_type(ftUnknown),
            front_prev_state(false),
            front_state(false),
            rawdata(false)
        {
            si.id = uniset::DefaultObjectId;
            si.node = uniset::DefaultObjectId;
            cal.minRaw = cal.maxRaw = cal.minCal = cal.maxCal = cal.precision = 0;
            ti.invert = false;
            ti.hilimit = 0;
            ti.lowlimit = 0;
            ti.id = uniset::DefaultObjectId;
            ti.state = IONotifyController_i::NormalThreshold;
            ti.tv_sec = 0;
            ti.tv_nsec = 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 safeval;   
        long defval;    
        bool safevalDefined = { false }; 
 
        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)
        uniset::ObjectId d_id;  
        IOController::IOStateList::iterator d_it; 
        long d_value; 
        long d_off_value; 
        UniversalIO::IOType d_iotype;
 
        // Порог
        uniset::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;
        uniset::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 processingF64asAI( IOBase* it, double new_val, const std::shared_ptr<SMInterface>& shm, bool force );
        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 double processingF64asAO( 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);
    };
    // --------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // IOBase_H_
// -----------------------------------------------------------------------------