IOController.h

См. документацию.
00001 /* This file is part of the UniSet project
00002  * Copyright (c) 2002 Free Software Foundation, Inc.
00003  * Copyright (c) 2002 Pavel Vainerman
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00018  */
00019 // --------------------------------------------------------------------------
00024 // -------------------------------------------------------------------------- 
00025 #ifndef IOController_H_
00026 #define IOController_H_
00027 //---------------------------------------------------------------------------
00028 #include <map>
00029 #include <list>
00030 #include <sigc++/sigc++.h>
00031 #include "IOController_i.hh"
00032 #include "UniSetTypes.h"
00033 #include "ObjectsManager.h"
00034 #include "Configuration.h"
00035 #include "Mutex.h"
00036 //---------------------------------------------------------------------------
00038 class IOController: 
00039         public ObjectsManager,
00040         public POA_IOController_i
00041 {
00042     public:
00043     
00044         IOController(const std::string name, const std::string section);
00045         IOController(UniSetTypes::ObjectId id);
00046         ~IOController();
00047 
00048         virtual UniSetTypes::ObjectType getType(){ return UniSetTypes::getObjectType("IOController"); }
00049 
00050         virtual CORBA::Boolean getState( const IOController_i::SensorInfo& si );
00051         virtual CORBA::Long getValue( const IOController_i::SensorInfo& si );   
00052 
00053 //     -------------------- !!!!!!!!! ---------------------------------
00054 //      Реализуются конкретным i/o контроллером
00055 //      Не забывайте писать реализацию этих функций
00056         virtual void setState( const IOController_i::SensorInfo& si, CORBA::Boolean state,
00057                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00058         virtual void setValue( const IOController_i::SensorInfo& si, CORBA::Long value,
00059                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00060 
00061         virtual void fastSetState( const IOController_i::SensorInfo& si, CORBA::Boolean state,
00062                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00063         virtual void fastSetValue( const IOController_i::SensorInfo& si, CORBA::Long value,
00064                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00065 
00066 //     ----------------------------------------------------------------
00067 
00069         virtual void saveState(const IOController_i::SensorInfo& si, CORBA::Boolean state,
00070                                 UniversalIO::IOTypes type = UniversalIO::DigitalInput,
00071                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00072 
00073         virtual void fastSaveState(const IOController_i::SensorInfo& si, CORBA::Boolean state,
00074                                 UniversalIO::IOTypes type = UniversalIO::DigitalInput,
00075                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00076 
00078         virtual void saveValue(const IOController_i::SensorInfo& si, CORBA::Long value,
00079                                 UniversalIO::IOTypes type = UniversalIO::AnalogInput,
00080                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00081 
00082         virtual void fastSaveValue(const IOController_i::SensorInfo& si, CORBA::Long value,
00083                                 UniversalIO::IOTypes type = UniversalIO::AnalogInput,
00084                                 UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00085 
00086         virtual void setUndefinedState(const IOController_i::SensorInfo& si, 
00087                                         CORBA::Boolean undefined, 
00088                                         UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId );
00089 
00090 
00091         virtual IOController_i::ASensorInfoSeq* getSensorSeq(const UniSetTypes::IDSeq& lst);
00092         virtual UniSetTypes::IDSeq* setOutputSeq(const IOController_i::OutSeq& lst, UniSetTypes::ObjectId sup_id);
00093 
00094 //     ----------------------------------------------------------------
00095         virtual UniversalIO::IOTypes getIOType(const IOController_i::SensorInfo& si);
00096 
00097         virtual IOController_i::ASensorInfoSeq* getAnalogSensorsMap();
00098         virtual IOController_i::DSensorInfoSeq* getDigitalSensorsMap();
00099 
00100         virtual IOController_i::DigitalIOInfo getDInfo(const IOController_i::SensorInfo& si);
00101         virtual IOController_i::AnalogIOInfo getAInfo(const IOController_i::SensorInfo& si);
00102 
00103 
00104         virtual CORBA::Long getRawValue(const IOController_i::SensorInfo& si);
00105         virtual void calibrate(const IOController_i::SensorInfo& si, 
00106                                     const IOController_i::CalibrateInfo& ci,
00107                                     UniSetTypes::ObjectId adminId );
00108         
00109         IOController_i::CalibrateInfo getCalibrateInfo(const IOController_i::SensorInfo& si);
00110 
00111         inline IOController_i::SensorInfo SensorInfo(UniSetTypes::ObjectId id, 
00112                                 UniSetTypes::ObjectId node=UniSetTypes::conf->getLocalNode())
00113         {
00114             IOController_i::SensorInfo si;
00115             si.id = id;
00116             si.node = node;
00117             return si;
00118         };
00119 
00120         UniSetTypes::Message::Priority getPriority(const IOController_i::SensorInfo& si, 
00121                                                     UniversalIO::IOTypes type);
00122                                                     
00123         virtual IOController_i::ShortIOInfo getChangedTime(const IOController_i::SensorInfo& si);
00124 
00125         virtual IOController_i::ShortMapSeq* getSensors();
00126 
00127     public:
00128 
00129         struct DependsInfo;
00130         typedef std::list<DependsInfo> DependsList;
00131 
00136         typedef sigc::slot<void,DependsList::iterator,bool> DependsSlot;
00137         
00141         void setDependsSlot( DependsSlot sl );
00142         void setBlockDependsSlot( DependsSlot sl );
00143 
00144         // структуры для внутреннего хранения информации по датчикам
00145         struct UniDigitalIOInfo:
00146             public IOController_i::DigitalIOInfo
00147         {
00148             UniDigitalIOInfo():any(0),dlst_lock(false),block_state(false),db_ignore(false)
00149                 { undefined = false; blocked=false; }
00150             virtual ~UniDigitalIOInfo(){}
00151             
00152             UniDigitalIOInfo(IOController_i::DigitalIOInfo& r);
00153             UniDigitalIOInfo(const IOController_i::DigitalIOInfo& r);
00154             UniDigitalIOInfo(IOController_i::DigitalIOInfo* r);
00155 
00156             UniDigitalIOInfo& operator=(IOController_i::DigitalIOInfo& r);
00157             UniDigitalIOInfo& operator=(IOController_i::DigitalIOInfo* r);
00158             const UniDigitalIOInfo& operator=(const IOController_i::DigitalIOInfo& r);
00159         
00160             void* any;          
00162             DependsList dlst;   
00163             bool dlst_lock;     
00164             bool block_state;
00165             bool db_ignore;     
00167             UniSetTypes::uniset_spin_mutex val_lock; 
00168         };
00169 
00170         struct UniAnalogIOInfo:
00171             public IOController_i::AnalogIOInfo
00172         {
00173             UniAnalogIOInfo():any(0),dlst_lock(false),block_value(0),db_ignore(false)
00174                 { undefined = false; blocked=false; }
00175             virtual ~UniAnalogIOInfo(){}
00176 
00177             UniAnalogIOInfo(IOController_i::AnalogIOInfo& r);
00178             UniAnalogIOInfo(IOController_i::AnalogIOInfo* r);
00179             UniAnalogIOInfo(const IOController_i::AnalogIOInfo& r);
00180 
00181             UniAnalogIOInfo& operator=(IOController_i::AnalogIOInfo& r);
00182             const UniAnalogIOInfo& operator=(const IOController_i::AnalogIOInfo& r);
00183             UniAnalogIOInfo& operator=(IOController_i::AnalogIOInfo* r);
00184         
00185             void* any;          
00186             DependsList dlst;   
00187             bool dlst_lock;     
00188             long block_value;
00189             bool db_ignore;     
00191             UniSetTypes::uniset_spin_mutex val_lock; 
00192         };
00193 
00194 
00195         // Функции работы со списками датчиков (без изменения 'const')
00196         typedef std::map<UniSetTypes::KeyType, UniDigitalIOInfo> DIOStateList;
00197         typedef std::map<UniSetTypes::KeyType, UniAnalogIOInfo> AIOStateList;
00198     
00199         inline DIOStateList::iterator dioBegin(){ return dioList.begin(); }
00200         inline DIOStateList::iterator dioEnd(){ return dioList.end(); }
00201         inline DIOStateList::iterator dfind(UniSetTypes::KeyType k){ return dioList.find(k); }
00202         inline int dioCount(){ return dioList.size(); }     
00203 
00204         inline AIOStateList::iterator aioBegin(){ return aioList.begin(); }
00205         inline AIOStateList::iterator aioEnd(){ return aioList.end(); }
00206         inline AIOStateList::iterator afind(UniSetTypes::KeyType k){ return aioList.find(k); }
00207         inline int aioCount(){ return aioList.size(); }
00208 
00209         struct DependsInfo
00210         {
00211             DependsInfo( bool init=false );
00212             DependsInfo( IOController_i::SensorInfo& si,
00213                          DIOStateList::iterator& dit, AIOStateList::iterator& ait );
00214             
00215             IOController_i::SensorInfo si;
00216             DIOStateList::iterator dit;
00217             AIOStateList::iterator ait;
00218             bool block_invert;  
00219             bool init;
00220         };
00221 
00222         // доступ к элементам через итератор
00223         virtual void localSaveValue( AIOStateList::iterator& it, const IOController_i::SensorInfo& si,
00224                                         CORBA::Long newvalue, UniSetTypes::ObjectId sup_id );
00225         virtual void localSaveState( DIOStateList::iterator& it, const IOController_i::SensorInfo& si,
00226                                         CORBA::Boolean newstate, UniSetTypes::ObjectId sup_id );
00227 
00228         virtual void localSetState( DIOStateList::iterator& it, const IOController_i::SensorInfo& si,
00229                                         CORBA::Boolean newstate, UniSetTypes::ObjectId sup_id );
00230 
00231         virtual void localSetValue( AIOStateList::iterator& it, const IOController_i::SensorInfo& si,
00232                                         CORBA::Long value, UniSetTypes::ObjectId sup_id );
00233 
00234         virtual bool localGetState( DIOStateList::iterator& it, const IOController_i::SensorInfo& si );
00235         virtual long localGetValue( AIOStateList::iterator& it, const IOController_i::SensorInfo& si );
00236         
00237 
00242         virtual void localSetUndefinedState( AIOStateList::iterator& it, bool undefined,
00243                                                 const IOController_i::SensorInfo& si );
00244 
00245 
00246     protected:
00247             // переопределяем для добавления вызова регистрации датчиков
00248             virtual bool disactivateObject();
00249             virtual bool activateObject();
00250 
00252             virtual void sensorsRegistration(){};
00254             virtual void sensorsUnregistration();
00255     
00259             void dsRegistration( const UniDigitalIOInfo&, bool force=false );
00260             
00261 
00265             void asRegistration( const UniAnalogIOInfo&, bool force=false );
00266 
00267             
00269             void sUnRegistration(const IOController_i::SensorInfo& si);
00270             
00271             
00272             UniSetTypes::Message::Priority getMessagePriority(UniSetTypes::KeyType k, UniversalIO::IOTypes type);
00273             
00274             // ------------------------------
00275             inline IOController_i::DigitalIOInfo
00276                     DigitalIOInfo(bool s, UniversalIO::IOTypes t, const IOController_i::SensorInfo& si, 
00277                                     UniSetTypes::Message::Priority p = UniSetTypes::Message::Medium,
00278                                     bool defval=false )
00279             {
00280                 IOController_i::DigitalIOInfo di;
00281                 di.si = si;
00282                 di.state = s;
00283                 di.real_state = s;
00284                 di.type = t;
00285                 di.priority = p;
00286                 di.default_val = defval;
00287                 di.blocked = false;
00288                 return di;
00289             };
00290 
00291             inline IOController_i::AnalogIOInfo
00292                 AnalogIOInfo(long v, UniversalIO::IOTypes t, const IOController_i::SensorInfo& si, 
00293                                 UniSetTypes::Message::Priority p = UniSetTypes::Message::Medium,
00294                                 long defval=0, IOController_i::CalibrateInfo* ci=0 )
00295             {
00296                 IOController_i::AnalogIOInfo ai;
00297                 ai.si = si;
00298                 ai.type = t;
00299                 ai.value = v;
00300                 ai.priority = p;
00301                 ai.default_val = defval;
00302                 ai.real_value = v;
00303                 ai.blocked = false;
00304                 if( ci!=0 )
00305                     ai.ci = *ci;
00306                 else
00307                 {
00308                     ai.ci.minRaw = 0;
00309                     ai.ci.maxRaw = 0;
00310                     ai.ci.minCal = 0;
00311                     ai.ci.maxCal = 0;
00312                     ai.ci.sensibility = 0;
00313                     ai.ci.precision = 0;
00314                 }
00315                 return ai;  
00316             };
00317 
00318 
00320             virtual void logging(UniSetTypes::SensorMessage& sm);
00321             
00323             virtual void dumpToDB();
00324 
00325 
00326         IOController(); 
00327 
00328         // доступ к списку c изменением только для своих
00329         DIOStateList::iterator mydioBegin();
00330         DIOStateList::iterator mydioEnd();
00331         AIOStateList::iterator myaioBegin();
00332         AIOStateList::iterator myaioEnd();
00333         AIOStateList::iterator myafind(UniSetTypes::KeyType k);
00334         DIOStateList::iterator mydfind(UniSetTypes::KeyType k);
00335 
00336         // --------------------------
00337         // ФИЛЬТРОВАНИЕ
00338         // 
00339         typedef sigc::slot<bool,const UniAnalogIOInfo&, CORBA::Long, UniSetTypes::ObjectId> AFilterSlot;
00340         typedef sigc::slot<bool,const UniDigitalIOInfo&, CORBA::Boolean, UniSetTypes::ObjectId> DFilterSlot;
00341         typedef std::list<AFilterSlot> AFilterSlotList;
00342         typedef std::list<DFilterSlot> DFilterSlotList;
00343 
00344         /*
00345             Фильтрующая функция должна возвращать:
00346             TRUE - если значение 'нормальное'
00347             FALSE - если значение не подходит (отбрасывается)
00348         
00349             Пример использования: 
00350                 addAFilter( sigc::mem_fun(my,&MyClass::my_filter) );
00351         */
00352         AFilterSlotList::iterator addAFilter( AFilterSlot sl, bool push_front=false );
00353         DFilterSlotList::iterator addDFilter( DFilterSlot sl, bool push_front=false );
00354         void eraseAFilter(AFilterSlotList::iterator& it);
00355         void eraseDFilter(DFilterSlotList::iterator& it);
00356 
00357         // функии проверки текущего значения
00358         bool checkDFilters( const UniDigitalIOInfo& ai, CORBA::Boolean newstate, UniSetTypes::ObjectId sup_id );
00359         bool checkAFilters( const UniAnalogIOInfo& ai, CORBA::Long& newvalue, UniSetTypes::ObjectId sup_id );
00360 
00361         inline bool afiltersEmpty(){ return afilters.empty(); }
00362         inline bool dfiltersEmpty(){ return dfilters.empty(); }
00363         inline int afiltersSize(){ return afilters.size(); }
00364         inline int dfiltersSize(){ return dfilters.size(); }
00365 
00366         // ---------------------------
00367         // note: функция вызывается рекурсивно!!!
00368         void updateDepends( IOController::DependsList& lst, bool undefined, bool& lock );
00369         void updateBlockDepends( IOController::DependsList& lst, bool blk_state, bool& lock );
00370 
00371         void setCheckLockValuePause( int msec );
00372         inline int getCheckLockValuePause(){ return checkLockValuePause; }
00373     
00374     private:        
00375         friend class AskDumper;
00376     
00377         DIOStateList dioList;   
00378         AIOStateList aioList;   
00380         UniSetTypes::uniset_mutex dioMutex; 
00381         UniSetTypes::uniset_mutex aioMutex; 
00383         bool isPingDBServer;    // флаг связи с DBServer-ом 
00384 
00385         AFilterSlotList afilters; 
00386         DFilterSlotList dfilters; 
00388         DependsSlot dslot; 
00389         DependsSlot bslot; 
00390         int checkLockValuePause;
00391 
00392         UniSetTypes::uniset_mutex loggingMutex; 
00393 };
00394 
00395 #endif