1 #ifndef _ots_FEVInterface_h_
2 #define _ots_FEVInterface_h_
4 #include "otsdaq-core/FiniteStateMachine/VStateMachine.h"
5 #include "otsdaq-core/WorkLoopManager/WorkLoop.h"
6 #include "otsdaq-core/Configurable/Configurable.h"
7 #include "otsdaq-core/FECore/FESlowControlsWorkLoop.h"
11 #include "otsdaq-core/FECore/FESlowControlsChannel.h"
18 #define __ARGS__ FEVInterface::frontEndMacroInArgs_t argsIn, FEVInterface::frontEndMacroOutArgs_t argsOut
19 #define __GET_ARG_IN__(X,Y) getFEMacroInputArgumentValue<Y> (argsIn ,X)
20 #define __GET_ARG_OUT__(X) FEVInterface::getFEMacroOutputArgument (argsOut,X)
21 #define __SET_ARG_OUT__(X,Y) FEVInterface::setFEMacroOutputArgumentValue (argsOut,X,Y)
26 class FrontEndHardwareBase;
27 class FrontEndFirmwareBase;
28 class FEInterfaceConfigurationBase;
37 ,
Configurable (theXDAQContextConfigTree, configurationPath)
38 , interfaceUID_ (interfaceUID)
39 , interfaceType_ (theXDAQContextConfigTree_.getBackNode(theConfigurationPath_).getNode(
"FEInterfacePluginName").getValue<std::string>())
40 , daqHardwareType_ (
"NOT SET")
41 , firmwareType_ (
"NOT SET")
42 , slowControlsWorkLoop_ (interfaceUID +
"-SlowControls",
this)
59 const std::string& getInterfaceUID (
void)
const {
return interfaceUID_;}
60 const std::string& getDaqHardwareType (
void)
const {
return daqHardwareType_;}
61 const std::string& getFirmwareType (
void)
const {
return firmwareType_;}
62 const std::string& getInterfaceType (
void)
const {
return interfaceType_;}
64 virtual int universalRead (
char* address,
char* returnValue) = 0;
65 virtual void universalWrite (
char* address,
char* writeValue) = 0;
66 const unsigned int& getUniversalAddressSize (
void) {
return universalAddressSize_;}
67 const unsigned int& getUniversalDataSize (
void) {
return universalDataSize_;}
69 FrontEndHardwareBase* getHardwareP (
void)
const {
return theFrontEndHardware_;}
70 FrontEndFirmwareBase* getFirmwareP (
void)
const {
return theFrontEndFirmware_;}
72 void runSequenceOfCommands (
const std::string &treeLinkName);
76 void configure (
void) { __COUT__ <<
"\t Configure" << std::endl; runSequenceOfCommands(
"LinkToConfigureSequence"); }
77 void start (std::string runNumber) { __COUT__ <<
"\t Start" << std::endl; runSequenceOfCommands(
"LinkToStartSequence"); }
78 void stop (
void) { __COUT__ <<
"\t Stop" << std::endl; runSequenceOfCommands(
"LinkToStopSequence"); }
79 void halt (
void) { stop();}
80 void pause (
void) { stop();}
81 void resume (
void) { start(
"");}
82 bool running (
void) {
return false;}
88 void configureSlowControls (
void);
89 bool slowControlsRunning (
void);
90 void startSlowControlsWorkLooop (
void) {slowControlsWorkLoop_.startWorkLoop();}
91 void stopSlowControlsWorkLooop (
void) {slowControlsWorkLoop_.stopWorkLoop();}
100 using frontEndMacroInArg_t = std::pair<
const std::string ,
const std::string >;
101 using frontEndMacroInArgs_t =
const std::vector<frontEndMacroInArg_t> &;
102 using frontEndMacroOutArg_t = std::pair<
const std::string , std::string >;
103 using frontEndMacroOutArgs_t = std::vector<frontEndMacroOutArg_t> &;
104 using frontEndMacroFunction_t = void (
ots::FEVInterface::* )(frontEndMacroInArgs_t, frontEndMacroOutArgs_t);
108 const std::vector<std::string> &namesOfInputArgs,
109 const std::vector<std::string> &namesOfOutputArgs,
110 const uint8_t requiredUserPermissions)
111 :macroFunction_(feMacroFunction)
112 ,namesOfInputArguments_(namesOfInputArgs)
113 ,namesOfOutputArguments_(namesOfOutputArgs)
114 ,requiredUserPermissions_(requiredUserPermissions)
117 const frontEndMacroFunction_t macroFunction_;
118 const std::vector<std::string> namesOfInputArguments_, namesOfOutputArguments_;
119 const uint8_t requiredUserPermissions_;
121 const std::map<std::string, frontEndMacroStruct_t>& getMapOfFEMacroFunctions() {
return mapOfFEMacroFunctions_;}
126 bool workLoopThread(toolbox::task::WorkLoop* workLoop){continueWorkLoop_ = running();
return continueWorkLoop_;}
127 std::string interfaceUID_;
128 std::string interfaceType_;
131 std::string daqHardwareType_;
132 std::string firmwareType_;
134 FrontEndHardwareBase* theFrontEndHardware_ =
nullptr;
135 FrontEndFirmwareBase* theFrontEndFirmware_ =
nullptr;
137 unsigned int universalAddressSize_ = 0;
138 unsigned int universalDataSize_ = 0;
141 std::map<std::string, FESlowControlsChannel> mapOfSlowControlsChannels_;
142 FESlowControlsWorkLoop slowControlsWorkLoop_;
147 std::map<std::string, frontEndMacroStruct_t> mapOfFEMacroFunctions_;
148 void registerFEMacroFunction(
const std::string &feMacroName, frontEndMacroFunction_t feMacroFunction,
const std::vector<std::string> &namesOfInputArgs,
const std::vector<std::string> &namesOfOutputArgs, uint8_t requiredUserPermissions);
151 static bool isNumber(
const std::string& s) ;
152 static const std::string& getFEMacroInputArgument (frontEndMacroInArgs_t &argsIn,
const std::string &argName);
154 static std::string& getFEMacroOutputArgument (frontEndMacroOutArgs_t &argsOut,
const std::string& argName);
158 std::string& setFEMacroOutputArgumentValue(
159 frontEndMacroOutArgs_t &argsOut,
160 const std::string &argName,
const T& value)
const
162 std::string& argOut = getFEMacroOutputArgument(argsOut,argName);
163 std::stringstream ss; ss << value;
172 T getFEMacroInputArgumentValue(
173 FEVInterface::frontEndMacroInArgs_t &argsIn,
const std::string &argName)
178 const std::string& data = FEVInterface::getFEMacroInputArgument(argsIn, argName);
183 if(!FEVInterface::isNumber(data))
185 __SS__ <<
"Error extracting value for argument named '" <<
186 argName <<
".' The value '" << data <<
"' is not a number!" << std::endl;
187 __COUT__ <<
"\n" << ss.str();
188 throw std::runtime_error(ss.str());
192 if(
typeid(
double) ==
typeid(retValue))
193 retValue = strtod(data.c_str(),0);
194 else if(
typeid(
float) ==
typeid(retValue))
195 retValue = strtof(data.c_str(),0);
196 else if(data.size() > 2 && data[1] ==
'x')
197 retValue = strtol(data.c_str(),0,16);
198 else if(data.size() > 1 && data[0] ==
'b')
199 retValue = strtol(data.substr(1).c_str(),0,2);
201 retValue = strtol(data.c_str(),0,10);
207 std::string getFEMacroInputArgumentValue<std::string> (FEVInterface::frontEndMacroInArgs_t &argsIn,
const std::string &argName);