extensions/ModbusSlave/MBSlave.h

// -----------------------------------------------------------------------------
#ifndef _MBSlave_H_
#define _MBSlave_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <map>
#include <vector>
#include "UniSetObject_LT.h"
#include "modbus/ModbusTypes.h"
#include "modbus/ModbusServerSlot.h"
#include "PassiveTimer.h"
#include "Trigger.h"
#include "Mutex.h"
#include "SMInterface.h"
#include "SharedMemory.h"
#include "IOBase.h"
#include "VTypes.h"
#include "ThreadCreator.h"
// -----------------------------------------------------------------------------
class MBSlave:
    public UniSetObject_LT
{
    public:
        MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0, std::string prefix="mbs" );
        virtual ~MBSlave();
    
        static MBSlave* init_mbslave( int argc, const char* const* argv,
                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
                                            std::string prefix="mbs" );

        static void help_print( int argc, const char* const* argv );

        static const int NoSafetyState=-1;

        enum AccessMode
        {
            amRW,
            amRO,
            amWO
        };

        struct IOProperty:
            public IOBase
        {
            ModbusRTU::ModbusData mbreg;    
            AccessMode amode;
            VTypes::VType vtype;    
            int wnum;               
            IOProperty():
                mbreg(0),
                amode(amRW),
                vtype(VTypes::vtUnknown),
                wnum(0)
            {}

            friend std::ostream& operator<<( std::ostream& os, IOProperty& p );
        };

        inline long getAskCount(){ return askCount; }

    protected:

        ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query, 
                                                    ModbusRTU::ReadCoilRetMessage& reply );
        ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query, 
                                                    ModbusRTU::ReadInputStatusRetMessage& reply );

        ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query, 
                                                    ModbusRTU::ReadOutputRetMessage& reply );

        ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query, 
                                                    ModbusRTU::ReadInputRetMessage& reply );

        ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query, 
                                                        ModbusRTU::ForceSingleCoilRetMessage& reply );

        ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query, 
                                                    ModbusRTU::ForceCoilsRetMessage& reply );


        ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query, 
                                                        ModbusRTU::WriteOutputRetMessage& reply );

        ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query, 
                                                        ModbusRTU::WriteSingleOutputRetMessage& reply );

//      ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query, 
//                                                          ModbusRTU::JournalCommandRetMessage& reply );

        ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query, 
                                                            ModbusRTU::SetDateTimeRetMessage& reply );

        ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query, 
                                                            ModbusRTU::RemoteServiceRetMessage& reply );

        ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                                            ModbusRTU::FileTransferRetMessage& reply );

        ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query, 
                                                        ModbusRTU::DiagnosticRetMessage& reply );

        ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query, 
                                                        ModbusRTU::MEIMessageRetRDI& reply );
        
        virtual ModbusRTU::mbErrCode checkRegister( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val )
        { return ModbusRTU::erNoError; }

        typedef std::map<ModbusRTU::ModbusData,IOProperty> IOMap;
        IOMap iomap;            
        ModbusServerSlot* mbslot;
        ModbusRTU::ModbusAddr addr;         
        UniSetTypes::uniset_mutex mbMutex;

        xmlNode* cnode;
        std::string s_field;
        std::string s_fvalue;

        SMInterface* shm;

        virtual void processingMessage( UniSetTypes::VoidMessage *msg );
        void sysCommand( UniSetTypes::SystemMessage *msg );
        void sensorInfo( UniSetTypes::SensorMessage* sm );
        void askSensors( UniversalIO::UIOCommand cmd ); 
        void waitSMReady();
        void execute_rtu();
        void execute_tcp();

        virtual bool activateObject();
        
        // действия при завершении работы
        virtual void sigterm( int signo );

        void initIterators();
        bool initItem( UniXML_iterator& it );
        bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );

        void readConfiguration();
        bool check_item( UniXML_iterator& it );

        ModbusRTU::mbErrCode real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData val );
        ModbusRTU::mbErrCode real_read( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val );
        ModbusRTU::mbErrCode much_real_read( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int count );
        ModbusRTU::mbErrCode much_real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int count );
        
        ModbusRTU::mbErrCode real_read_it( IOMap::iterator& it, ModbusRTU::ModbusData& val );
        ModbusRTU::mbErrCode real_write_it( IOMap::iterator& it, ModbusRTU::ModbusData& val );
    private:
        MBSlave();
        bool initPause;
        UniSetTypes::uniset_mutex mutex_start;
        ThreadCreator<MBSlave>* thr;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat;
        IOController::AIOStateList::iterator aitHeartBeat;
        UniSetTypes::ObjectId test_id;

        IOController::AIOStateList::iterator aitAskCount;
        UniSetTypes::ObjectId askcount_id;

        IOController::DIOStateList::iterator ditRespond;
        UniSetTypes::ObjectId respond_id;
        bool respond_invert;

        PassiveTimer ptTimeout;
        long askCount;
        typedef std::map<ModbusRTU::mbErrCode,unsigned int> ExchangeErrorMap;
        ExchangeErrorMap errmap;    
        bool activated;
        int activateTimeout;
        bool pingOK;
        timeout_t wait_msec;
        bool force;     
        bool mbregFromID;

        typedef std::map<int,std::string> FileList;
        FileList flist;
        std::string prefix;
        
        ModbusRTU::ModbusData buf[ModbusRTU::MAXLENPACKET/2+1];  
        // данные для ответа на запрос 0x2B(43)/0x0E(14)
        // 'MEI' - modbus encapsulated interface
        // 'RDI' - read device identification
        typedef std::map<int,std::string> MEIValMap;
        typedef std::map<int,MEIValMap> MEIObjIDMap;
        typedef std::map<int,MEIObjIDMap> MEIDevIDMap;

        MEIDevIDMap meidev;
};
// -----------------------------------------------------------------------------
#endif // _MBSlave_H_
// -----------------------------------------------------------------------------