CanBusInterface.h

Go to the documentation of this file.

#ifndef __CANBUSINTERFACE_H__
#define __CANBUSINTERFACE_H__

#include "UaCalcItem.h"
#include "CANOpenServerConfig.h"
#include "CanBusAccess.h"
#include "CanBusObject.h"
#include "ControlInterface.h"
#include "UaCanBusObject.h"
#include "UaDeviceMethod.h"

#include "NmBuildingAutomation.h"
#include "UaCanTrace.h"

#include <list>
#include <map>
#include <vector>
#include <string>

extern bool noExit;
namespace CanOpen {

        class UserDevice::AbstractHardware;
        typedef  std::map<string, vector<UaControlVariable *> > mapDataVariable;


        class CanBusInterface: public ControlInterface
        {
        public:

                class predCanBus
                {
                public:
                        predCanBus(string s)
                        {
                                nport = s;
                        }
                        bool operator()(CanBusObject *cbo)
                        {
                                string bname = cbo->getCanBusAddress();
                                int n = bname.find(':');
                                int l = bname.length() - (n+1);
                                bool b = bname.compare(n+1,l, nport) == 0;
                                return b;
                        }
                private:
                        string nport;
                };

                CanBusInterface();
                virtual ~CanBusInterface();
                virtual void    closeInterface();

                virtual UaStatus initialize();                  // initialize interface and devices
                
                virtual UaStatus CreateXmlParser(UaString &sXmlFileName/*,UaString &sLogFileName*/);            
                virtual pUserDeviceStruct *createInterfaceEntry(pUserDeviceStruct* parent, int code, ::xml_schema::type* conf , UaNode* pAS);

                virtual IOManager* getIOManager(UaNode* pUaNode,  OpcUa_Int32 attributeId);

                virtual VariableHandle* getVariableHandler(Session* session, VariableHandle::ServiceType serviceType, OpcUa_NodeId *nodeid, OpcUa_Int32 attributeId);


//              bool isCanObject(int code) { return (find(m_CanObjects.begin(),m_CanObjects.end(),code) != m_CanObjects.end()); }

//              bool isCanItem(int code) { 
//                      return (find(m_CanItems.begin(),m_CanItems.end(),code) != m_CanItems.end());
//              }
//              bool isCanMethod(int code) { return (find(m_CanMethods.begin(),m_CanMethods.end(),code) != m_CanMethods.end()); }

                virtual bool isTraceVariable(UaNodeId uaTraceId)
                {
                        return (uaTraceId == UaNodeId("TraceLevel", getNodeManager()->getNameSpaceIndex()));
                }
                virtual void putTraceFunctions(OpcUa_DataValue *mvar)
                {
                        OpcUa_Variant vdata;
                        vdata   =  mvar->Value;
                        UaCanTrace::putTraceFunctions(vdata.Value.Int32);
                }

                virtual bool isDeviceVariable(UaNodeId uaDevVar)
                {
                        bool ret = true;
                        OpcUa_UInt32 nn = uaDevVar.identifierNumeric();
                        if (nn == BA_STARTPROGRAM || nn == BA_CALCITEM)
                                ret = false ;
                        return ret;
                }

                static void initCalculation();

                static void addCalcCompilerItem(AddressSpace::UaCalcItem *ucci);

//              virtual UaStatus CreateAddressSpace(NmBuildingAutomation *nManager);
                virtual UaStatus CreateAddressSpace(AddressSpace::NmBuildingAutomation *nManager, NodeManagerNodeSetXml* pXmlNodeManager, NodeManagerConfig *pDefaultNodeManager);

                virtual UaStatus getCanTraceSettings(
                        OpcUa_UInt32&  uMaxTraceEntries,    // Maximum number of trace entries in one trace file
                        OpcUa_UInt32&  uMaxBackupFiles,     // Maximum number of backup files
                        UaString&      sTraceFile           // Name and path of the trace file
                        ) 
                {
                        uMaxTraceEntries =  m_uCanMaxTraceEntries;
                        uMaxBackupFiles =  m_uCanMaxBackupFiles;
                        sTraceFile =   m_sLogFileName;
                        return OpcUa_Good;
                }

                UaNodeId getCanNodeNodeId(UaNode *pNode);
                
//              UaStatus createTypeNodes();  //! create of ua node types
                UaStatus createNodeTypes();  
                UaStatus createCanbuses();   

                UaStatus createNodes(CANBUS::NODE_sequence &nd, UaControlDeviceGeneric *pcanbus);

                static UaStatus CompileItems(OpcUa::BaseObjectType *pParent, CanOpenOpcServerConfig::ITEM_sequence &itnd, CanOpenOpcServerConfig::REGEXPR_sequence &regex, NmBuildingAutomation * nManager);

                static UaStatus createListInitmethod(CanOpenOpcServerConfig::atStartup_sequence &ex, UaControlDeviceGeneric *parent, NmBuildingAutomation *nManager);

                static UaStatus createListInitSet(CanOpenOpcServerConfig::SET_sequence &ex, UaControlDeviceGeneric *parent, NmBuildingAutomation *nManager);

                static UaStatus executeInitMethod();
                static UaStatus variableInitSet();
                
                static UaStatus createRegVariable(ITEM &itemvar, CanOpenOpcServerConfig::REGEXPR_sequence &regex, mapDataVariable& pvariables, OpcUa::BaseObjectType *pcn, OpcUa_Int32 &minVar, NmBuildingAutomation *nManager);

                static unique_ptr<CanBusAccess> g_pCanaccess ;                  
//              static UaCalcCompiler *g_pCompiler;
                static list<UaDeviceMethod<UaControlDeviceGeneric> *>           m_listInitMethod;
                struct InitSet {
                        OpcUa::BaseDataVariableType *setVar;
                        UaString value;
                };
                static list<struct InitSet>     m_listInitSet;
                static vector< AddressSpace::UaCalcItem *> m_vCCI;  
                UaCanTrace *m_Trace;
        private:

                list<CanBusObject *>    m_CanBusList;                                           // the list of CanBus in the system
                map<OpcUa_UInt32,UserDevice::AbstractHardware *> factory;       // map name of class to provide an object

//              vector<OpcUa_UInt32> m_CanObjects;                                      // map code functions of objects
//              vector<OpcUa_UInt32> m_CanMethods;                                      // map code functions of methods
//              vector<OpcUa_UInt32> m_CanItems;                                        // map code functions of items

                CanOpenOpcServerConfig::NODETYPE_sequence       m_nodetypes;    
                CanOpenOpcServerConfig::CANBUS_sequence         m_canbuses;             
                CanOpenOpcServerConfig::ITEM_sequence           m_items;                
                CanOpenOpcServerConfig::REGEXPR_sequence        m_regexprisson; 
                CanOpenOpcServerConfig::SETTINGS_optional       m_settings;             
                CanOpenOpcServerConfig::atStartup_sequence      m_execute;              
                CanOpenOpcServerConfig::SET_sequence    m_setvalue;             

                        UaString        m_sLocale;
                UaString        m_sLogFileName;
                OpcUa_UInt32  m_uCanMaxTraceEntries;    // Maximum number of trace entries in one trace file
                OpcUa_UInt32  m_uCanMaxBackupFiles;     // Maximum number of backup files
        };
}

#endif