Merge branch 'feature/daqmon-template-rpc' into 'develop'

Templatize RPC calls in gemdaqmonitor

Closes #13

See merge request cmsgemonline/cmsgemos!9

CMakeLists.txt

@@ -73,7 +73,7 @@ add_subdirectory(gembase)
 add_subdirectory(gemonlinedb)
 add_subdirectory(gemreadout)
 add_subdirectory(gemhardware)
-add_subdirectory(gemdaqmonitor)
+add_subdirectory(gemmonitor)
 add_subdirectory(gemsupervisor)
 add_subdirectory(gemcalibration)
 

gemdaqmonitor/CMakeLists.txt

-cmsgemos_add_module(
-    daqmon
-    SOURCES
-    version.cpp
-    DaqMonitor.cpp
-    ShelfMonitor.cpp
-    ShelfMonitorWeb.cpp
-)
-
-target_link_libraries(gemdaqmon PUBLIC gembase)
-target_link_libraries(gemdaqmon PUBLIC gemutils)
-
-target_link_libraries(gemdaqmon PUBLIC xhal::client)
-
-target_link_libraries(gemdaqmon PUBLIC Boost::iostreams)
-
-
-target_link_libraries(gemdaqmon PRIVATE gemhardware_utils)
-target_link_libraries(gemdaqmon PRIVATE gemhardware_devices)
-
-target_link_libraries(gemdaqmon PRIVATE xDAQ::toolbox)
-target_link_libraries(gemdaqmon PRIVATE xDAQ::xcept)
-target_link_libraries(gemdaqmon PRIVATE xDAQ::xdaq)
-target_link_libraries(gemdaqmon PRIVATE xDAQ::xoap)
-
-target_link_libraries(gemdaqmon PUBLIC Boost::boost) # for Boost.Algorithm

gemdaqmonitor/interface/exception/Exception.h

-/// @file gem/daqmon/exception/Exception.h
-
-#ifndef GEM_DAQMON_EXCEPTION_EXCEPTION_H
-#define GEM_DAQMON_EXCEPTION_EXCEPTION_H
-
-#include <string>
-
-#include "gem/utils/exception/Exception.h"
-
-// The gem::daqmon exceptions.
-#define GEM_DAQMON_DEFINE_EXCEPTION(EXCEPTION_NAME) GEM_DEFINE_EXCEPTION(EXCEPTION_NAME, daqmon)
-GEM_DAQMON_DEFINE_EXCEPTION(Exception)
-GEM_DAQMON_DEFINE_EXCEPTION(SoftwareProblem)
-GEM_DAQMON_DEFINE_EXCEPTION(ValueError)
-
-// The gem::daqmon alarms.
-#define GEM_DAQMON_DEFINE_ALARM(ALARM_NAME) GEM_DAQMON_DEFINE_EXCEPTION(ALARM_NAME)
-GEM_DAQMON_DEFINE_ALARM(MonitoringFailureAlarm)
-
-#endif // GEM_DAQMON_EXCEPTION_EXCEPTION_H

gemmonitor/CMakeLists.txt

+cmsgemos_add_module(
+    monitor
+    SOURCES
+    version.cpp
+    DaqMonitor.cpp
+    ShelfMonitor.cpp
+    ShelfMonitorWeb.cpp
+)
+
+target_link_libraries(gemmonitor PUBLIC gembase)
+target_link_libraries(gemmonitor PUBLIC gemutils)
+
+target_link_libraries(gemmonitor PUBLIC xhal::client)
+
+target_link_libraries(gemmonitor PUBLIC Boost::iostreams)
+
+
+target_link_libraries(gemmonitor PRIVATE gemhardware_utils)
+target_link_libraries(gemmonitor PRIVATE gemhardware_devices)
+
+target_link_libraries(gemmonitor PRIVATE xDAQ::toolbox)
+target_link_libraries(gemmonitor PRIVATE xDAQ::xcept)
+target_link_libraries(gemmonitor PRIVATE xDAQ::xdaq)
+target_link_libraries(gemmonitor PRIVATE xDAQ::xoap)
+
+target_link_libraries(gemmonitor PUBLIC Boost::boost) # for Boost.Algorithm

gemdaqmonitor/interface/DaqMonitor.h → gemmonitor/interface/DaqMonitor.h

 /// @file DAQMonitor.h
 
-#ifndef GEM_DAQMON_DAQMONITOR_H
-#define GEM_DAQMON_DAQMONITOR_H
+#ifndef GEM_MONITOR_DAQMONITOR_H
+#define GEM_MONITOR_DAQMONITOR_H
 
 #include "gem/base/GEMApplication.h"
 #include "gem/base/GEMMonitor.h"
 //#include "xhal/rpc/utils.h"
 #include <xhal/client/XHALInterface.h>
+#include <xhal/client/call.h>
 
 #include <fstream>
 #include <iostream>
@@ -23,25 +24,25 @@ namespace gem {
 namespace base {
     class GEMApplication;
 }
-namespace daqmon {
+namespace monitor {
 
     class DaqMonitor : public gem::base::GEMMonitor, public xhal::client::XHALInterface {
     public:
-        /// Constructor from GEMMonitor derived class
-        /// @param board_domain_name The domain name of the AMC card
-        /// @param optohybridManager logger Log4cplus logger
-        /// @param gemApp Calling GEMApplication instance
-        /// @param index Index
+	/// Constructor from GEMMonitor derived class
+	/// @param board_domain_name The domain name of the AMC card
+	/// @param optohybridManager logger Log4cplus logger
+	/// @param gemApp Calling GEMApplication instance
+	/// @param index Index
 
-        struct LabelData {
-            std::string labelId;
-            std::string labelClass;
-            std::string labelValue;
-        };
+	struct LabelData {
+	    std::string labelId;
+	    std::string labelClass;
+	    std::string labelValue;
+	};
 
-        DaqMonitor(const std::string& board_domain_name, log4cplus::Logger& logger, base::GEMApplication* gemApp, int const& index);
+	DaqMonitor(const std::string& board_domain_name, log4cplus::Logger& logger, base::GEMApplication* gemApp, int const& index);
 
-        virtual ~DaqMonitor();
+	virtual ~DaqMonitor();
 
         virtual void reconnect();
 
@@ -88,8 +89,10 @@ namespace daqmon {
 
     protected:
         void init();
-        static const int NOH = 12;
-
+	//static
+	const int NOH = 12;
+	int ohMask = 0xfff;
+	
     private:
         is_toolbox_ptr is_daqmon;
         std::string is_name;
@@ -106,7 +109,7 @@ namespace daqmon {
 
     }; // class DaqMonitor
 
-} // namespace gem::daqmon
+} // namespace gem::monitor
 } // namespace gem
 
-#endif // GEM_DAQMON_MONITOR_H
+#endif // GEM_MONITOR_MONITOR_H

gemdaqmonitor/interface/ShelfMonitor.h → gemmonitor/interface/ShelfMonitor.h

 /// @file ShelfMonitor.h
 
-#ifndef GEM_DAQMON_SHELFMONITOR_H
-#define GEM_DAQMON_SHELFMONITOR_H
+#ifndef GEM_MONITOR_SHELFMONITOR_H
+#define GEM_MONITOR_SHELFMONITOR_H
 
 #include <string>
 #include <vector>
@@ -10,14 +10,14 @@
 #include "gem/utils/Lock.h"
 #include "gem/utils/LockGuard.h"
 
-#include "gem/daqmon/exception/Exception.h"
+#include "gem/monitor/exception/Exception.h"
 
-#include "gem/daqmon/DaqMonitor.h"
+#include "gem/monitor/DaqMonitor.h"
 
 #define NAMC 12
 
 namespace gem {
-namespace daqmon {
+namespace monitor {
 
     class DaqMonitor;
 
@@ -60,7 +60,7 @@ namespace daqmon {
         log4cplus::Logger m_logger; //FIXME should be removed!
         std::string m_state;
     };
-} // namespace gem::daqmon
+} // namespace gem::monitor
 } // namespace gem
 
-#endif // GEM_DAQMON_SHELFMONITOR_H
+#endif // GEM_MONITOR_SHELFMONITOR_H

gemdaqmonitor/interface/ShelfMonitorWeb.h → gemmonitor/interface/ShelfMonitorWeb.h

 /// @file ShelfMonitorWeb.h
 
-#ifndef GEM_DAQMON_SHELFMONITORWEB_H
-#define GEM_DAQMON_SHELFMONITORWEB_H
+#ifndef GEM_MONITOR_SHELFMONITORWEB_H
+#define GEM_MONITOR_SHELFMONITORWEB_H
 
 #include <memory>
 
 #include "gem/base/GEMWebApplication.h"
 
 namespace gem {
-namespace daqmon {
+namespace monitor {
 
     class ShelfMonitor;
 
@@ -42,8 +42,8 @@ namespace daqmon {
         size_t level;
         // GEMSupervisor *gemSupervisorP__;
         // GEMSupervisorWeb(GEMSupervisorWeb const&);
-    }; // class gem::daqmon::ShelfMonitorWeb
-} // namespace gem::daqmon
+    }; // class gem::monitor::ShelfMonitorWeb
+} // namespace gem::monitor
 } // namespace gem
 
-#endif // GEM_DAQMON_SHELFMONITORWEB_H
+#endif // GEM_MONITOR_SHELFMONITORWEB_H

gemmonitor/interface/exception/Exception.h

+/// @file gem/daqmon/exception/Exception.h
+
+#ifndef GEM_MONITOR_EXCEPTION_EXCEPTION_H
+#define GEM_MONITOR_EXCEPTION_EXCEPTION_H
+
+#include <string>
+
+#include "gem/utils/exception/Exception.h"
+
+// The gem::daqmon exceptions.
+#define GEM_MONITOR_DEFINE_EXCEPTION(EXCEPTION_NAME) GEM_DEFINE_EXCEPTION(EXCEPTION_NAME, monitor)
+GEM_MONITOR_DEFINE_EXCEPTION(Exception)
+GEM_MONITOR_DEFINE_EXCEPTION(SoftwareProblem)
+GEM_MONITOR_DEFINE_EXCEPTION(ValueError)
+
+// The gem::daqmon alarms.
+#define GEM_MONITOR_DEFINE_ALARM(ALARM_NAME) GEM_MONITOR_DEFINE_EXCEPTION(ALARM_NAME)
+GEM_MONITOR_DEFINE_ALARM(MonitoringFailureAlarm)
+
+#endif // GEM_MONITOR_EXCEPTION_EXCEPTION_H

gemdaqmonitor/interface/version.h → gemmonitor/interface/version.h

 /// @file version.h
 
-#ifndef GEM_DAQMON_VERSION_H
-#define GEM_DAQMON_VERSION_H
+#ifndef GEM_MONITOR_VERSION_H
+#define GEM_MONITOR_VERSION_H
 
 #ifndef DOXYGEN_IGNORE_THIS
 
 #include "config/PackageInfo.h"
 
 namespace gem {
-namespace daqmon {
+namespace monitor {
 
 #define GEMDAQMONITOR_VERSION_MAJOR 1
 #define GEMDAQMONITOR_VERSION_MINOR 0
@@ -24,7 +24,7 @@ namespace daqmon {
 #endif
 
     const std::string project = "cmsgemos";
-    const std::string package = "daqmon";
+    const std::string package = "monitor";
     const std::string versions = GEMDAQMONITOR_FULL_VERSION_LIST;
     const std::string summary = "<FILL ME>";
     const std::string description = "";
@@ -39,4 +39,4 @@ namespace daqmon {
 
 #endif // DOXYGEN_IGNORE_THIS
 
-#endif // GEM_DAQMON_VERSION_H
+#endif // GEM_MONITOR_VERSION_H

gemdaqmonitor/src/DaqMonitor.cpp → gemmonitor/src/DaqMonitor.cpp

@@ -4,19 +4,20 @@
 /// author: M. Dalchenko
 /// date:
 
-#include "gem/daqmon/DaqMonitor.h"
+#include "gem/monitor/DaqMonitor.h"
 #include "gem/hardware/utils/GEMCrateUtils.h"
+#include <gem/rpc/daq_monitor.h>
 #include <bitset>
 #include <iomanip>
 
 typedef gem::base::utils::GEMInfoSpaceToolBox::UpdateType GEMUpdateType;
 
 //FIXME establish required arguments, eventually retrieve from the config
-gem::daqmon::DaqMonitor::DaqMonitor(const std::string& board_domain_name, log4cplus::Logger& logger, gem::base::GEMApplication* gemApp, int const& index)
+gem::monitor::DaqMonitor::DaqMonitor(const std::string& board_domain_name, log4cplus::Logger& logger, gem::base::GEMApplication* gemApp, int const& index)
     : gem::base::GEMMonitor::GEMMonitor(logger, gemApp, index)
     ,
-    //xhal::client::XHALInterface(board_domain_name, logger) //FIXME: if using shared logger, then XHALInterface overtakes everything and logging from XDAQ doesn't go through
-    xhal::client::XHALInterface(board_domain_name) //Works as is, providing a bit messy logging, but with all info in place
+      //xhal::client::XHALInterface(board_domain_name, logger) //FIXME: if using shared logger, then XHALInterface overtakes everything and logging from XDAQ doesn't go through
+      xhal::client::XHALInterface(board_domain_name) //Works as is, providing a bit messy logging, but with all info in place
 {
     CMSGEMOS_DEBUG("DaqMonitor::DaqMonitor:: entering constructor");
     if (isConnected) { //TODO Add to the app monitoring space? Need to know in order to mask in web interface the boards which failed to connect
@@ -36,16 +37,16 @@ gem::daqmon::DaqMonitor::DaqMonitor(const std::string& board_domain_name, log4cp
 
     logCnt = 0;
 
-    CMSGEMOS_DEBUG("gem::daqmon::DaqMonitor : constructor done");
+    CMSGEMOS_DEBUG("gem::monitor::DaqMonitor : constructor done");
 }
 
-gem::daqmon::DaqMonitor::~DaqMonitor()
+gem::monitor::DaqMonitor::~DaqMonitor()
 {
-    CMSGEMOS_DEBUG("gem::daqmon::DaqMonitor : destructor called");
+    CMSGEMOS_DEBUG("gem::monitor::DaqMonitor : destructor called");
     //TODO
 }
 
-void gem::daqmon::DaqMonitor::reconnect()
+void gem::monitor::DaqMonitor::reconnect()
 {
     if (!isConnected) {
         this->connect();
@@ -56,12 +57,12 @@ void gem::daqmon::DaqMonitor::reconnect()
     }
 }
 
-void gem::daqmon::DaqMonitor::reset()
+void gem::monitor::DaqMonitor::reset()
 {
     //TODO
 }
 
-void gem::daqmon::DaqMonitor::addDaqMonitorable(const std::string& m_name, const std::string& m_monset, const std::string& m_spacename)
+void gem::monitor::DaqMonitor::addDaqMonitorable(const std::string& m_name, const std::string& m_monset, const std::string& m_spacename)
 {
     //FIXME Putting "DUMMY" as reg full name at the moment. May want to define all tables here and pass as a list to RPC
     is_daqmon->createUInt32(m_name, 0xFFFFFFFF, NULL, GEMUpdateType::HW32);
@@ -71,7 +72,7 @@ void gem::daqmon::DaqMonitor::addDaqMonitorable(const std::string& m_name, const
     m_LabelData.insert(std::make_pair(m_name, new LabelData { m_board_domain_name + "." + m_name, "label label-default", "FFFFFFFF" }));
 }
 
-void gem::daqmon::DaqMonitor::setupDaqMonitoring()
+void gem::monitor::DaqMonitor::setupDaqMonitoring()
 {
     // create the values to be monitored in the info space
     addMonitorableSet("DAQ_MAIN", "DAQ_MONITORING");
@@ -86,7 +87,7 @@ void gem::daqmon::DaqMonitor::setupDaqMonitoring()
         "EVENT_SENT",
         "TTS_STATE",
         "INPUT_ENABLE_MASK",
-        "INPUT_AUTOKILL_MASK" };
+    };
     for (auto monname : v_daq_main) {
         addDaqMonitorable(monname, "DAQ_MAIN", "DAQ_MONITORING");
     }
@@ -145,15 +146,12 @@ void gem::daqmon::DaqMonitor::setupDaqMonitoring()
 
     addMonitorableSet("OH_MAIN", "DAQ_MONITORING");
     //OH_MAIN monitorables
-    v_oh_main = { ".FW_VERSION",
+    v_oh_main = { 
+        ".FW_VERSION",
         ".EVENT_COUNTER",
         ".EVENT_RATE",
-        ".GTX.TRK_ERR",
-        ".GTX.TRG_ERR",
-        ".GBT.TRK_ERR",
-        ".CORR_VFAT_BLK_CNT",
-        ".COUNTERS.SEU",
-        ".STATUS.SEU" };
+	".CORR_VFAT_BLK_CNT",
+    };
     for (unsigned int i = 0; i < NOH; ++i) {
         for (auto monname : v_oh_main) {
             addDaqMonitorable("OH" + std::to_string(i) + monname, "OH_MAIN", "DAQ_MONITORING");
@@ -194,41 +192,49 @@ void gem::daqmon::DaqMonitor::setupDaqMonitoring()
     }
 }
 
-void gem::daqmon::DaqMonitor::updateMonitorables()
+void gem::monitor::DaqMonitor::updateMonitorables()
 {
     CMSGEMOS_DEBUG("DaqMonitor: Updating Monitorables");
     try {
         updateDAQmain();
     } catch (...) {
-        return;
+        CMSGEMOS_DEBUG("DaqMonitor: Failed DAQmain");
+        //return;
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level... If even a updateDAQmain fails, do not attempt to do anything else for this AMC board
     try {
         updateDAQOHmain();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed DAQOHmain");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateTTCmain();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed TTCmain");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateTRIGGERmain();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed TRIGGERmain");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateTRIGGEROHmain();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed TRIGGEROHmain");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateOHmain();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed OHmain");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateOHSCA();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed OHSCA");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateOHSysmon();
     } catch (...) {
+	CMSGEMOS_DEBUG("DaqMonitor: Failed OHSysmon");
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
     try {
         updateDAQmainTableContent();
@@ -237,7 +243,7 @@ void gem::daqmon::DaqMonitor::updateMonitorables()
 
         // dump the monitorables every ten updates
         if (logCnt % 10 == 0) {
-            CMSGEMOS_INFO("gem::daqmon::DaqMonitor Logging monitorables");
+            CMSGEMOS_INFO("gem::monitor::DaqMonitor Logging monitorables");
             time_t t = time(0); // get time now
             struct tm* now = localtime(&t);
             char buffer[80];
@@ -268,215 +274,158 @@ void gem::daqmon::DaqMonitor::updateMonitorables()
     } //FIXME Define meaningful exceptions and intercept here or eventually at a different level...
 }
 
-void gem::daqmon::DaqMonitor::updateDAQmain()
+void gem::monitor::DaqMonitor::updateDAQmain()
 {
     CMSGEMOS_DEBUG("DaqMonitor: Update DAQ main table");
-    req = wisc::RPCMsg("daq_monitor.getmonDAQmain");
+    std::map<std::string, uint32_t> rspMap;
     try {
-        rsp = rpc.call_method(req);
-    }
-    STANDARD_CATCH;
+    	rspMap = xhal::client::call<::daqmon::getmonDAQmain>(rpc);
+    } STANDARD_CATCH;
 
     try {
-        if (rsp.get_key_exists("error")) {
-            CMSGEMOS_ERROR("DAQ_MAIN update error: " << rsp.get_string("error").c_str());
-            //throw xhal::client::XHALException("DAQ_MAIN update failed");
-        }
-        auto monlist = m_monitorableSetsMap.find("DAQ_MAIN");
-        for (auto monitem = monlist->second.begin(); monitem != monlist->second.end(); ++monitem) {
-            (monitem->second.infoSpace)->setUInt32(monitem->first, rsp.get_word(monitem->first));
-        }
-    }
-    STANDARD_CATCH;
+	auto monlist = m_monitorableSetsMap.find("DAQ_MAIN");
+    	for (auto monitem : monlist->second) {
+    	    (monitem.second.infoSpace)->setUInt32(monitem.first, rspMap[monitem.first]);
+    	}
+    } STANDARD_CATCH;
+    
 }
 
-void gem::daqmon::DaqMonitor::updateDAQOHmain()
+void gem::monitor::DaqMonitor::updateDAQOHmain()
 {
     CMSGEMOS_DEBUG("DaqMonitor: Update DAQ OH main table");
-    req = wisc::RPCMsg("daq_monitor.getmonDAQOHmain");
-    req.set_word("NOH", NOH);
+    std::map<std::string, uint32_t> rspMap;
     try {
-        rsp = rpc.call_method(req);
-    }
-    STANDARD_CATCH;
-
+	rspMap = xhal::client::call<::daqmon::getmonDAQOHmain>(rpc, ohMask);
+    } STANDARD_CATCH;
+    
     try {
-        if (rsp.get_key_exists("error")) {
-            CMSGEMOS_ERROR("DAQ_OH_MAIN update error: " << rsp.get_string("error").c_str());
-            //throw xhal::client::XHALException("DAQ_OH_MAIN update failed");
-        }
-        auto monlist = m_monitorableSetsMap.find("DAQ_OH_MAIN");
-        for (auto monitem = monlist->second.begin(); monitem != monlist->second.end(); ++monitem) {
-            (monitem->second.infoSpace)->setUInt32(monitem->first, rsp.get_word(monitem->first));
-        }
-    }
-    STANDARD_CATCH;
+	auto monlist = m_monitorableSetsMap.find("DAQ_OH_MAIN");
+	for (auto monitem : monlist->second) {
+	    (monitem.second.infoSpace)->setUInt32(monitem.first, rspMap[monitem.first]);
+	}
+    } STANDARD_CATCH;
 }
 
-void gem::daqmon::DaqMonitor::updateTTCmain()
+void gem::monitor::DaqMonitor::updateTTCmain()
 {
     CMSGEMOS_DEBUG("DaqMonitor: Update TTC main table");
-    req = wisc::RPCMsg("daq_monitor.getmonTTCmain");
+    CMSGEMOS_DEBUG("DaqMonitor: Update TTC main table");
+    std::map<std::string, uint32_t> rspMap;
     try {
-        rsp = rpc.call_method(req);
-    }
-    STANDARD_CATCH;
+	rspMap = xhal::client::call<::daqmon::getmonTTCmain>(rpc);
+    } STANDARD_CATCH;
 
     try {
-        if (rsp.get_key_exists("error")) {
-            CMSGEMOS_ERROR("DAQ_TTC_MAIN update error: " << rsp.get_string("error").c_str());
-            //throw xhal::client::XHALException("DAQ_TTC_MAIN update failed");
-        }
-        auto monlist = m_monitorableSetsMap.find("DAQ_TTC_MAIN");
-        for (auto monitem = monlist->second.begin(); monitem != monlist->second.end(); ++monitem) {
-            (monitem->second.infoSpace)->setUInt32(monitem->first, rsp.get_word(monitem->first));
-        }
-    }
-    STANDARD_CATCH;
+	auto monlist = m_monitorableSetsMap.find("DAQ_TTC_MAIN");
+	for (auto monitem : monlist->second) {
+	    (monitem.second.infoSpace)->setUInt32(monitem.first, rspMap[monitem.first]);
+	}
+    } STANDARD_CATCH;
 }
 
-void gem::daqmon::DaqMonitor::updateTRIGGERmain()
+void gem::monitor::DaqMonitor::updateTRIGGERmain()
 {
     CMSGEMOS_DEBUG("DaqMonitor: Update TRIGGER main table");
-    req = wisc::RPCMsg("daq_monitor.getmonTRIGGERmain");
-    req.set_word("NOH", NOH);
+    std::map<std::string, uint32_t> rspMap;
     try {
-        rsp = rpc.call_method(req);
-    }
-    STANDARD_CATCH;
-
+	rspMap = xhal::client::call<::daqmon::getmonTRIGGERmain>(rpc, ohMask);
+    } STANDARD_CATCH;
     try {
-        if (rsp.get_key_exists("error")) {
-            CMSGEMOS_ERROR("DAQ_TRIGGER_MAIN update error: " << rsp.get_string("error").c_str());
-            //throw xhal::client::XHALException("DAQ_TRIGGER_MAIN update failed");
-        }
-        auto monlist = m_monitorableSetsMap.find("DAQ_TRIGGER_MAIN");
-        for (auto monitem = monlist->second.begin(); monitem != monlist->second.end(); ++monitem) {
-            (monitem->second.infoSpace)->setUInt32(monitem->first, rsp.get_word(monitem->first));
-        }
-    }
-    STANDARD_CATCH;
+	auto monlist = m_monitorableSetsMap.find("DAQ_TRIGGER_MAIN");
+	for (auto monitem : monlist->second) {
+	    (monitem.second.infoSpace)->setUInt32(monitem.first, rspMap[monitem.first]);
+	}
+    } STANDARD_CATCH;
+    
 }
 
-void gem::daqmon::DaqMonitor::updateTRIGGEROHmain()
+void gem::monitor::DaqMonitor::updateTRIGGEROHmain()
 {
     CMSGEMOS_DEBUG("DaqMonitor: Update TRIGGER OH main table");
-    req = wisc::RPCMsg("daq_monitor.getmonTRIGGEROHmain");
-    req.set_word("NOH", NOH);
+    std::map<std::string, uint32_t> rspMap;
     try {
-        rsp = rpc.call_method(req);
-    }
-    STANDARD_CATCH;
-
+	rspMap = xhal::client::call<::daqmon::getmonTRIGGEROHmain>(rpc, ohMask);
+    } STANDARD_CATCH;
     try {
-        if (rsp.get_key_exists("error")) {
-            CMSGEMOS_ERROR("DAQ_TRIGGER_OH_MAIN update error: " << rsp.get_string("error").c_str());
-            //throw xhal::client::XHALException("DAQ_TRIGGER_OH_MAIN update failed");
-        }
-        auto monlist = m_monitorableSetsMap.find("DAQ_TRIGGER_OH_MAIN");
-        for (auto monitem = monlist->second.begin(); monitem != monlist->second.end(); ++monitem) {
-            (monitem->second.infoSpace)->setUInt32(monitem->first, rsp.get_word(monitem->first));
-        }
-    }
-    STANDARD_CATCH;
+	auto monlist = m_monitorableSetsMap.find("DAQ_TRIGGER_OH_MAIN");
+	for (auto monitem : monlist->second) {
+	    (monitem.second.infoSpace)->setUInt32(monitem.first, rspMap[monitem.first]);