extensions/ModbusSlave/MBSlave.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 _MBSlave_H_
#define _MBSlave_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <memory>
#include <map>
#include <unordered_map>
#include <vector>
#include <condition_variable>
#include <atomic>
#include <mutex>
#include "UniSetObject.h"
#include "modbus/ModbusTypes.h"
#include "modbus/ModbusServerSlot.h"
#include "modbus/ModbusTCPServer.h"
#include "modbus/ModbusTCPServerSlot.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"
#include "LogServer.h"
#include "LogAgregator.h"
#include "VMonitor.h"
// -----------------------------------------------------------------------------
#ifndef vmonit
#define vmonit( var ) vmon.add( #var, var )
#endif
// -------------------------------------------------------------------------
namespace uniset
{
    // -----------------------------------------------------------------------------
    // -----------------------------------------------------------------------------
    class MBSlave:
        public UniSetObject
    {
        public:
            MBSlave( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "mbs" );
            virtual ~MBSlave();
 
            static std::shared_ptr<MBSlave> init_mbslave(int argc, const char* const* argv,
                    uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
                    const std::string& prefix = "mbs" );
 
            static void help_print( int argc, const char* const* argv );
 
            static const int NoSafetyState = -1;
 
            enum AccessMode
            {
                amRW,
                amRO,
                amWO
            };
 
            std::string amode2str( AccessMode m );
 
            struct BitRegProperty;
 
            struct IOProperty:
                public IOBase
            {
                ModbusRTU::ModbusData mbreg;    
                AccessMode amode;
                VTypes::VType vtype;    
                size_t wnum;               
                size_t nbyte;              
                std::shared_ptr<BitRegProperty> bitreg; 
                ModbusRTU::RegID regID;
 
                IOProperty():
                    mbreg(0),
                    amode(amRW),
                    vtype(VTypes::vtUnknown),
                    wnum(0),
                    nbyte(0),
                    regID(0)
                {}
 
                friend std::ostream& operator<<( std::ostream& os, IOProperty& p );
            };
 
 
            struct BitRegProperty
            {
                typedef std::vector<IOProperty> BitSensorMap;
 
                ModbusRTU::ModbusData mbreg; 
                BitSensorMap bvec;
 
                BitRegProperty(): mbreg(0), bvec(ModbusRTU::BitsPerData) {}
 
                bool check( const IOController_i::SensorInfo& si );
 
                friend std::ostream& operator<<( std::ostream& os, BitRegProperty& p );
                friend std::ostream& operator<<( std::ostream& os, BitRegProperty* p );
            };
 
            inline long getConnCount()
            {
                return connCount;
            }
 
            inline std::shared_ptr<LogAgregator> getLogAggregator()
            {
                return loga;
            }
            inline std::shared_ptr<DebugStream> log()
            {
                return mblog;
            }
 
            virtual uniset::SimpleInfo* getInfo( const char* userparam = 0 ) override;
 
#ifndef DISABLE_REST_API
            // http API
            virtual Poco::JSON::Object::Ptr httpHelp( const Poco::URI::QueryParameters& p ) override;
            virtual Poco::JSON::Object::Ptr httpRequest( const std::string& req, const Poco::URI::QueryParameters& p ) override;
#endif
 
        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 );
 
            // т.к. в функциях (much_real_read,nuch_real_write) расчёт на отсортированность IOMap
            // то использовать unordered_map нельзя
            typedef std::map<ModbusRTU::RegID, IOProperty> RegMap;
 
            typedef std::unordered_map<ModbusRTU::ModbusAddr, RegMap> IOMap;
 
            IOMap iomap;  
            // т.к. пороговые датчики не связаны напрямую с обменом, создаём для них отдельный список
            // и отдельно его проверяем потом
            typedef std::list<IOBase> ThresholdList;
            ThresholdList thrlist;
 
            std::shared_ptr<ModbusServerSlot> mbslot;
            std::unordered_set<ModbusRTU::ModbusAddr> vaddr; 
            std::string default_mbaddr = { "" };
 
            xmlNode* cnode = { 0 };
            std::string s_field = { "" };
            std::string s_fvalue = { "" };
            int default_mbfunc = {0}; // функция по умолчанию, для вычисления RegID
 
            std::shared_ptr<SMInterface> shm;
 
            virtual void sysCommand( const uniset::SystemMessage* msg ) override;
            virtual void sensorInfo( const uniset::SensorMessage* sm ) override;
            virtual void timerInfo( const uniset::TimerMessage* tm ) override;
            void askSensors( UniversalIO::UIOCommand cmd );
            bool waitSMReady();
            virtual void execute_rtu();
            virtual void execute_tcp();
            virtual void updateStatistics();
            virtual void updateTCPStatistics();
            virtual void updateThresholds();
            virtual void postReceiveEvent( ModbusRTU::mbErrCode res );
            void runTCPServer();
 
            virtual bool activateObject() override;
            virtual bool deactivateObject() override;
 
            // действия при завершении работы
            virtual void finalThread();
 
            enum Timer
            {
                tmCheckExchange
            };
 
            uniset::timeout_t checkExchangeTime = { 10000 }; // контроль "живости" потока обмена, мсек
 
            virtual void initIterators();
            bool initItem( UniXML::iterator& it );
            bool readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec );
 
            void readConfiguration();
            bool check_item( UniXML::iterator& it );
 
            ModbusRTU::mbErrCode real_write( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData val, const int fn = 0 );
            ModbusRTU::mbErrCode real_write( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData* dat, size_t& i, size_t count, const int fn = 0  );
            ModbusRTU::mbErrCode real_read( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData& val, const int fn = 0  );
            ModbusRTU::mbErrCode much_real_read( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData* dat, size_t count, const int fn = 0  );
            ModbusRTU::mbErrCode much_real_write(RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData* dat, size_t count, const int fn = 0  );
 
            ModbusRTU::mbErrCode real_read_it( RegMap& rmap, RegMap::iterator& it, ModbusRTU::ModbusData& val );
            ModbusRTU::mbErrCode real_bitreg_read_it( std::shared_ptr<BitRegProperty>& bp, ModbusRTU::ModbusData& val );
            ModbusRTU::mbErrCode real_read_prop( IOProperty* p, ModbusRTU::ModbusData& val );
 
            ModbusRTU::mbErrCode real_write_it(RegMap& rmap, RegMap::iterator& it, ModbusRTU::ModbusData* dat, size_t& i, size_t count );
            ModbusRTU::mbErrCode real_bitreg_write_it( std::shared_ptr<BitRegProperty>& bp, const ModbusRTU::ModbusData val );
            ModbusRTU::mbErrCode real_write_prop(IOProperty* p, ModbusRTU::ModbusData* dat, size_t& i, size_t count );
 
#ifndef DISABLE_REST_API
            // http api
            Poco::JSON::Object::Ptr request_regs( const std::string& req, const Poco::URI::QueryParameters& p );
            Poco::JSON::Object::Ptr get_regs(ModbusRTU::ModbusAddr addr, const RegMap& rmap, const std::vector<std::string>& q_regs );
            Poco::JSON::Object::Ptr get_reginfo( const IOProperty& prop );
#endif
            MBSlave();
            timeout_t initPause = { 3000 };
            uniset::uniset_rwmutex mutex_start;
            std::unique_ptr< ThreadCreator<MBSlave> > thr;
 
            std::mutex mutexStartNotify;
            std::condition_variable startNotifyEvent;
 
            PassiveTimer ptHeartBeat;
            uniset::ObjectId sidHeartBeat = { uniset::DefaultObjectId };
            long maxHeartBeat = { 10 };
            IOController::IOStateList::iterator itHeartBeat;
            uniset::ObjectId sidTestSMReady = {uniset::DefaultObjectId };
 
            IOController::IOStateList::iterator itAskCount;
            uniset::ObjectId askcount_id = { uniset::DefaultObjectId };
 
            IOController::IOStateList::iterator itRespond;
            uniset::ObjectId respond_id = { uniset::DefaultObjectId };
            bool respond_invert = { false };
 
            PassiveTimer ptTimeout;
            long connCount = { 0 };
            long restartTCPServerCount = { 0 };
 
            std::atomic_bool activated = { false };
            std::atomic_bool canceled = {false };
            timeout_t activateTimeout = { 20000 }; // msec
            bool smPingOK = { false };
            timeout_t wait_msec = { 3000 };
            bool force = { false };        
            bool mbregFromID = {0};
            bool checkMBFunc = {0};
            bool noMBFuncOptimize = {0}; // флаг отключающий принудительное преобразование функций (0x06->0x10, 0x05->0x0F) см. initItem()
 
            int getOptimizeWriteFunction( const int fn ); // функция возвращает оптимизированную функцию (если оптимизация включена)
 
            typedef std::unordered_map<int, std::string> FileList;
            FileList flist;
            std::string prefix = { "" };
            std::string prop_prefix = { "" };
 
            ModbusRTU::ModbusData buf[ModbusRTU::MAXLENPACKET / 2 + 1]; 
            // данные для ответа на запрос 0x2B(43)/0x0E(14)
            // 'MEI' - modbus encapsulated interface
            // 'RDI' - read device identification
            typedef std::unordered_map<int, std::string> MEIValMap;
            typedef std::unordered_map<int, MEIValMap> MEIObjIDMap;
            typedef std::unordered_map<int, MEIObjIDMap> MEIDevIDMap;
 
            MEIDevIDMap meidev;
 
            std::shared_ptr<LogAgregator> loga;
            std::shared_ptr<DebugStream> mblog;
            std::shared_ptr<LogServer> logserv;
            std::string logserv_host = {""};
            int logserv_port = {0};
            VMonitor vmon;
            std::string mbtype = { "" };
 
            // ----------------------------------------------------------------------------
            // TCPServer section..
            void initTCPClients( UniXML::iterator confnode );
 
            timeout_t sockTimeout = { 30000 };  
            timeout_t sessTimeout = { 2000 };  
            timeout_t updateStatTime = { 4000 };
            ModbusTCPServer::Sessions sess; 
            std::mutex sessMutex;
            size_t sessMaxNum = { 5 };
            std::shared_ptr<ModbusTCPServerSlot> tcpserver;
 
            struct ClientInfo
            {
                ClientInfo(): iaddr(""), respond_s(uniset::DefaultObjectId), invert(false),
                    askCount(0), askcount_s(uniset::DefaultObjectId)
                {
                    ptTimeout.setTiming(0);
                }
 
                std::string iaddr = { "" };
 
                uniset::ObjectId respond_s = { uniset::DefaultObjectId };
                IOController::IOStateList::iterator respond_it;
                bool invert = { false };
                PassiveTimer ptTimeout;
                timeout_t tout = { 2000 };
 
                long askCount = { 0 };
                uniset::ObjectId askcount_s = { uniset::DefaultObjectId };
                IOController::IOStateList::iterator askcount_it;
 
                inline void initIterators( const std::shared_ptr<SMInterface>& shm )
                {
                    shm->initIterator( respond_it );
                    shm->initIterator( askcount_it );
                }
 
                const std::string getShortInfo() const;
            };
 
            typedef std::unordered_map<std::string, ClientInfo> ClientsMap;
            ClientsMap cmap;
 
            uniset::ObjectId sesscount_id = { uniset::DefaultObjectId };
            IOController::IOStateList::iterator sesscount_it;
 
            std::atomic_bool tcpCancelled = { true };
 
            bool tcpBreakIfFailRun = { false };
            timeout_t tcpRepeatCreateSocketPause = { 30000 }; 
    };
    // --------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // _MBSlave_H_
// -----------------------------------------------------------------------------