otsdaq  v2_00_00
FEVInterface.h
1 #ifndef _ots_FEVInterface_h_
2 #define _ots_FEVInterface_h_
3 
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"
8 
9 
10 //#include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
11 #include "otsdaq-core/FECore/FESlowControlsChannel.h"
12 
13 #include <string>
14 #include <iostream>
15 #include <vector>
16 #include <array>
17 
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)
22 
23 namespace ots
24 {
25 
26 class FrontEndHardwareBase;
27 class FrontEndFirmwareBase;
28 class FEInterfaceConfigurationBase;
29 //class SlowControlsChannelInfo;
30 
31 class FEVInterface : public VStateMachine, public WorkLoop, public Configurable
32 {
33 public:
34 
35  FEVInterface (const std::string& interfaceUID, const ConfigurationTree& theXDAQContextConfigTree, const std::string& configurationPath)
36 : WorkLoop (interfaceUID)
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)
43 {}
44 
45  virtual ~FEVInterface (void) {;}
46 
48  //start OLD - but keeping around for a while, in case we realize we need it
49  //
50  //virtual void initLocalGroup (int local_group_comm_) {std::cout << __PRETTY_FUNCTION__ << std::endl;}
51  //void setConfigurationManager(ConfigurationManager* configurationManager){theConfigurationManager_ = configurationManager;}
52  //virtual void configureDetector(const DACStream& theDACStream) = 0;
53  //virtual void resetDetector() = 0;
54  //virtual void configureFEW (void) = 0;
55  //
56  //end OLD
58 
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_;}
63 
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_;}
68 
69  FrontEndHardwareBase* getHardwareP (void) const {return theFrontEndHardware_;}
70  FrontEndFirmwareBase* getFirmwareP (void) const {return theFrontEndFirmware_;}
71 
72  void runSequenceOfCommands (const std::string &treeLinkName);
73 
75  //start State Machine handlers
76  void configure (void) { __COUT__ << "\t Configure" << std::endl; runSequenceOfCommands("LinkToConfigureSequence"); /*Run Configure Sequence Commands*/}
77  void start (std::string runNumber) { __COUT__ << "\t Start" << std::endl; runSequenceOfCommands("LinkToStartSequence"); /*Run Start Sequence Commands*/}
78  void stop (void) { __COUT__ << "\t Stop" << std::endl; runSequenceOfCommands("LinkToStopSequence"); /*Run Stop Sequence Commands*/}
79  void halt (void) { stop();}
80  void pause (void) { stop();}
81  void resume (void) { start("");}
82  bool running (void) { /*while(WorkLoop::continueWorkLoop_){;}*/ return false;}
83  //end State Machine handlers
85 
87  //start Slow Controls
88  void configureSlowControls (void);
89  bool slowControlsRunning (void);
90  void startSlowControlsWorkLooop (void) {slowControlsWorkLoop_.startWorkLoop();}
91  void stopSlowControlsWorkLooop (void) {slowControlsWorkLoop_.stopWorkLoop();}
92  //end Slow Controls
94 
95 
97  //start FE Macros
98 
99  //public types and functions for map of FE macros
100  using frontEndMacroInArg_t = std::pair<const std::string /* input arg name */ , const std::string /* arg input value */ >;
101  using frontEndMacroInArgs_t = const std::vector<frontEndMacroInArg_t> &;
102  using frontEndMacroOutArg_t = std::pair<const std::string /* output arg name */, std::string /* arg return value */>;
103  using frontEndMacroOutArgs_t = std::vector<frontEndMacroOutArg_t> &;
104  using frontEndMacroFunction_t = void (ots::FEVInterface::* )(frontEndMacroInArgs_t, frontEndMacroOutArgs_t); //void function (vector-of-inputs, vector-of-outputs)
105  struct frontEndMacroStruct_t //members fully define a front-end macro function
106  {
107  frontEndMacroStruct_t(const frontEndMacroFunction_t &feMacroFunction,
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)
115  {}
116 
117  const frontEndMacroFunction_t macroFunction_; //Note: must be called using this instance
118  const std::vector<std::string> namesOfInputArguments_, namesOfOutputArguments_;
119  const uint8_t requiredUserPermissions_;
120  };
121  const std::map<std::string, frontEndMacroStruct_t>& getMapOfFEMacroFunctions() {return mapOfFEMacroFunctions_;}
122  //end FE Macros
124 
125 protected:
126  bool workLoopThread(toolbox::task::WorkLoop* workLoop){continueWorkLoop_ = running(); /* in case users return false, without using continueWorkLoop_*/ return continueWorkLoop_;}
127  std::string interfaceUID_;
128  std::string interfaceType_;
129 
130 
131  std::string daqHardwareType_;
132  std::string firmwareType_;
133 
134  FrontEndHardwareBase* theFrontEndHardware_ = nullptr;
135  FrontEndFirmwareBase* theFrontEndFirmware_ = nullptr;
136 
137  unsigned int universalAddressSize_ = 0;
138  unsigned int universalDataSize_ = 0;
139 
140  //Controls members
141  std::map<std::string, FESlowControlsChannel> mapOfSlowControlsChannels_;
142  FESlowControlsWorkLoop slowControlsWorkLoop_;
143 
144 
145  //FE Macro Function members and helper functions:
146 
147  std::map<std::string, frontEndMacroStruct_t> mapOfFEMacroFunctions_; //Map of FE Macro functions members
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);
149 
150 public: //for external specialized template access
151  static bool isNumber(const std::string& s) ;
152  static const std::string& getFEMacroInputArgument (frontEndMacroInArgs_t &argsIn, const std::string &argName);
153 protected:
154  static std::string& getFEMacroOutputArgument (frontEndMacroOutArgs_t &argsOut, const std::string& argName);
155 
156 
157  template<class T>
158  std::string& setFEMacroOutputArgumentValue(
159  frontEndMacroOutArgs_t &argsOut,
160  const std::string &argName, const T& value) const
161  {
162  std::string& argOut = getFEMacroOutputArgument(argsOut,argName);
163  std::stringstream ss; ss << value;
164  argOut = ss.str();
165  return argOut;
166  }
167 
168 };
169 
170 
171 template<class T>
172 T getFEMacroInputArgumentValue(
173  FEVInterface::frontEndMacroInArgs_t &argsIn, const std::string &argName)
174 {
175  //stolen from ConfigurationView
176  // only handles number types (strings are handled in non-template function override
177 
178  const std::string& data = FEVInterface::getFEMacroInputArgument(argsIn, argName);
179 
180 
181  T retValue;
182 
183  if(!FEVInterface::isNumber(data))
184  {
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());
189  }
190  __COUTV__(data);
191 
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') //assume hex value
197  retValue = strtol(data.c_str(),0,16);
198  else if(data.size() > 1 && data[0] == 'b') //assume binary value
199  retValue = strtol(data.substr(1).c_str(),0,2); //skip first 'b' character
200  else
201  retValue = strtol(data.c_str(),0,10);
202 
203  return retValue;
204 }
205 //specialized template version of getFEMacroInputArgumentValue for string
206 template<>
207 std::string getFEMacroInputArgumentValue<std::string> (FEVInterface::frontEndMacroInArgs_t &argsIn, const std::string &argName);
208 
209 
210 }
211 
212 #endif