tmfe_rev0.h

Go to the documentation of this file.

/********************************************************************\
 
  Name:         tmfe.h
  Created by:   Konstantin Olchanski - TRIUMF
 
  Contents:     C++ MIDAS frontend
 
\********************************************************************/
 
#ifndef TMFE_H
#define TMFE_H
 
#include <stdint.h>
#include <string>
#include <vector>
//#include <mutex>
//#include "midas.h"
#include "mvodb.h"
 
// from midas.h
 
#define TID_BYTE      1       
#define TID_UINT8     1       
#define TID_SBYTE     2       
#define TID_INT8      2       
#define TID_CHAR      3       
#define TID_WORD      4       
#define TID_UINT16    4       
#define TID_SHORT     5       
#define TID_INT16     5       
#define TID_DWORD     6       
#define TID_UINT32    6       
#define TID_INT       7       
#define TID_INT32     7       
#define TID_BOOL      8       
#define TID_FLOAT     9       
#define TID_FLOAT32   9       
#define TID_DOUBLE   10       
#define TID_FLOAT64  10       
#define TID_BITFIELD 11       
#define TID_STRING   12       
#define TID_ARRAY    13       
#define TID_STRUCT   14       
#define TID_KEY      15       
#define TID_LINK     16       
#define TID_INT64    17       
#define TID_UINT64   18       
#define TID_QWORD    18       
#define TID_LAST     19       
#define MT_ERROR           (1<<0)     
#define MT_INFO            (1<<1)     
#define MT_DEBUG           (1<<2)     
#define MT_USER            (1<<3)     
#define MT_LOG             (1<<4)     
#define MT_TALK            (1<<5)     
#define MT_CALL            (1<<6)     
#define MT_ALL              0xFF      
#define MT_ERROR_STR       "ERROR"
#define MT_INFO_STR        "INFO"
#define MT_DEBUG_STR       "DEBUG"
#define MT_USER_STR        "USER"
#define MT_LOG_STR         "LOG"
#define MT_TALK_STR        "TALK"
#define MT_CALL_STR        "CALL"
 
#define MERROR             MT_ERROR, __FILE__, __LINE__ 
#define MINFO              MT_INFO,  __FILE__, __LINE__ 
#define MDEBUG             MT_DEBUG, __FILE__, __LINE__ 
#define MUSER              MT_USER,  __FILE__, __LINE__ 
#define MLOG               MT_LOG,   __FILE__, __LINE__ 
#define MTALK              MT_TALK,  __FILE__, __LINE__ 
#define MCALL              MT_CALL,  __FILE__, __LINE__ 
#if defined __GNUC__
#define MATTRPRINTF(a, b) __attribute__ ((format (printf, a, b)))
#else
#define MATTRPRINTF(a, b)
#endif
 
class TMFeError
{
 public:
   int error;
   std::string error_string;
 
 public:
   TMFeError() { // default ctor for success
      error = 0;
      error_string = "success";
   }
 
   TMFeError(int status, const std::string& str) { // ctor
      error = status;
      error_string = str;
   }
};
 
class TMFeCommon
{
 public:
   uint16_t EventID;
   uint16_t TriggerMask;
   std::string Buffer;
   int Type;
   int Source;
   std::string Format;
   bool Enabled;
   int ReadOn;
   int Period;
   double EventLimit;
   uint32_t NumSubEvents;
   int LogHistory;
   std::string FrontendHost;
   std::string FrontendName;
   std::string FrontendFileName;
   std::string Status;
   std::string StatusColor;
   bool Hidden;
   int WriteCacheSize;
 
 public:
   TMFeCommon(); // ctor
};
 
class TMFE;
class MVOdb;
 
class TMFeEquipment
{
 public:
   std::string fName;
   TMFeCommon *fCommon;
   TMFE* fMfe;
 
 public:
   int fBufferHandle;
   int fSerial;
 
 public:
   MVOdb* fOdbEq;           
   MVOdb* fOdbEqCommon;     
   MVOdb* fOdbEqSettings;   
   MVOdb* fOdbEqVariables;  
   MVOdb* fOdbEqStatistics; 
 
 public:
   double fStatEvents;
   double fStatBytes;
   double fStatEpS; // events/sec
   double fStatKBpS; // kbytes/sec (factor 1000, not 1024)
 
   double fStatLastTime;
   double fStatLastEvents;
   double fStatLastBytes;
 
 public:
   TMFeEquipment(TMFE* mfe, const char* name, TMFeCommon* common); // ctor
   TMFeError Init(); 
   TMFeError SendData(const char* data, int size);    
   TMFeError ComposeEvent(char* pevent, int size);
   TMFeError BkInit(char* pevent, int size);
   void*     BkOpen(char* pevent, const char* bank_name, int bank_type);
   TMFeError BkClose(char* pevent, void* ptr);
   int       BkSize(const char* pevent);
   TMFeError SendEvent(const char* pevent);
   TMFeError ZeroStatistics();
   TMFeError WriteStatistics();
   TMFeError SetStatus(const char* status, const char* color);
};
 
class TMFeRpcHandlerInterface
{
 public:
   virtual void HandleBeginRun();
   virtual void HandleEndRun();
   virtual void HandlePauseRun();
   virtual void HandleResumeRun();
   virtual void HandleStartAbortRun();
   virtual std::string HandleRpc(const char* cmd, const char* args);
};
 
class TMFePeriodicHandlerInterface
{
 public:
   virtual void HandlePeriodic() = 0;
};
 
class TMFePeriodicHandler
{
 public:
   TMFeEquipment *fEq;
   TMFePeriodicHandlerInterface *fHandler;
   double fLastCallTime;
   double fNextCallTime;
 
 public:
   TMFePeriodicHandler();
   ~TMFePeriodicHandler();
};
 
class TMFE
{
 public:
 
   std::string fHostname; 
   std::string fExptname; 
 
   std::string fFrontendName; 
   std::string fFrontendHostname; 
   std::string fFrontendFilename; 
 
 public:
   int  fDB; 
   MVOdb* fOdbRoot; 
 
 public:
   bool fShutdownRequested; 
 
 public:   
   std::vector<TMFeEquipment*> fEquipments;
   std::vector<TMFeRpcHandlerInterface*> fRpcHandlers;
   std::vector<TMFePeriodicHandler*> fPeriodicHandlers;
   double fNextPeriodic;
 
 public:
   bool fRpcThreadStarting;
   bool fRpcThreadRunning;
   bool fRpcThreadShutdownRequested;
 
   bool fPeriodicThreadStarting;
   bool fPeriodicThreadRunning;
   bool fPeriodicThreadShutdownRequested;
   
 private:
   static TMFE* gfMFE;
   
   TMFE(); 
   virtual ~TMFE(); 
 
 public:
   
   static TMFE* Instance();
   
   TMFeError Connect(const char* progname, const char* filename = NULL, const char*hostname = NULL, const char*exptname = NULL);
   TMFeError Disconnect();
 
   TMFeError RegisterEquipment(TMFeEquipment* eq);
   void RegisterRpcHandler(TMFeRpcHandlerInterface* handler); 
   void RegisterPeriodicHandler(TMFeEquipment* eq, TMFePeriodicHandlerInterface* handler); 
 
   void StartRpcThread();
   void StartPeriodicThread();
 
   void StopRpcThread();
   void StopPeriodicThread();
 
   TMFeError SetWatchdogSec(int sec);
 
   void PollMidas(int millisec);
   void MidasPeriodicTasks();
   void EquipmentPeriodicTasks();
 
   TMFeError TriggerAlarm(const char* name, const char* message, const char* aclass);
   TMFeError ResetAlarm(const char* name);
 
   void Msg(int message_type, const char *filename, int line, const char *routine, const char *format, ...) MATTRPRINTF(6,7);
 
   void SetTransitionSequenceStart(int seqno);
   void SetTransitionSequenceStop(int seqno);
   void SetTransitionSequencePause(int seqno);
   void SetTransitionSequenceResume(int seqno);
   void SetTransitionSequenceStartAbort(int seqno);
   void DeregisterTransitions();
   void DeregisterTransitionStart();
   void DeregisterTransitionStop();
   void DeregisterTransitionPause();
   void DeregisterTransitionResume();
   void DeregisterTransitionStartAbort();
   void RegisterTransitionStartAbort();
 
   static double GetTime(); 
   static void Sleep(double sleep_time_sec); 
   static std::string GetThreadId(); 
};
 
#endif
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */