EqEverything Class Reference

Inheritance diagram for EqEverything:

Collaboration diagram for EqEverything:

Public Member Functions
	EqEverything (const char *eqname, const char *eqfilename)
	~EqEverything ()
void	HandleUsage ()
TMFeResult	HandleInit (const std::vector< std::string > &args)
TMFeResult	HandleRpc (const char *cmd, const char *args, std::string &response)
TMFeResult	HandleBinaryRpc (const char *cmd, const char *args, std::vector< char > &response)
TMFeResult	HandleBeginRun (int run_number)
TMFeResult	HandleEndRun (int run_number)
TMFeResult	HandlePauseRun (int run_number)
TMFeResult	HandleResumeRun (int run_number)
TMFeResult	HandleStartAbortRun (int run_number)
void	SendData (double dvalue)
void	HandlePeriodic ()
bool	HandlePoll ()
void	HandlePollRead ()
Public Member Functions inherited from TMFeEquipment
	TMFeEquipment (const char *eqname, const char *eqfilename)
virtual	~TMFeEquipment ()
TMFeResult	EqInit (const std::vector< std::string > &args)
	Initialize equipment.
TMFeResult	EqPreInit ()
	Initialize equipment, before EquipmentBase::Init()
TMFeResult	EqPostInit ()
	Initialize equipment, after EquipmentBase::Init()
TMFeResult	EqReadCommon ()
	Read TMFeEqInfo from ODB /Equipment/NAME/Common.
TMFeResult	EqWriteCommon (bool create=false)
	Write TMFeEqInfo to ODB /Equipment/NAME/Common.
void	EqPollThread ()
void	EqStartPollThread ()
void	EqStopPollThread ()
TMFeResult	ComposeEvent (char *pevent, size_t size) const
TMFeResult	BkInit (char *pevent, size_t size) const
void *	BkOpen (char *pevent, const char *bank_name, int bank_type) const
TMFeResult	BkClose (char *pevent, void *ptr) const
int	BkSize (const char *pevent) const
TMFeResult	EqSendEvent (const char *pevent, bool write_to_odb=true)
TMFeResult	EqSendEvent (const std::vector< char > &event, bool write_to_odb=true)
TMFeResult	EqSendEvent (const std::vector< std::vector< char > > &event, bool write_to_odb=true)
TMFeResult	EqSendEvent (int sg_n, const char *sg_ptr[], const size_t sg_len[], bool write_to_odb=true)
TMFeResult	EqWriteEventToOdb (const char *pevent)
TMFeResult	EqZeroStatistics ()
TMFeResult	EqWriteStatistics ()
TMFeResult	EqSetStatus (const char *status, const char *color)
	TMFeEquipment (TMFE *mfe, const char *name, TMFeCommon *common)
TMFeError	Init ()
	Initialize equipment.
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)
Public Member Functions inherited from TMFeRpcHandlerInterface
virtual	~TMFeRpcHandlerInterface ()
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)

Additional Inherited Members
Public Attributes inherited from TMFeEquipment
std::string	fEqName
std::string	fEqFilename
bool	fEqConfEnableRpc = true
bool	fEqConfEnablePeriodic = true
bool	fEqConfEnablePoll = false
bool	fEqConfReadConfigFromOdb = true
bool	fEqConfEnabled = true
uint16_t	fEqConfEventID = 1
uint16_t	fEqConfTriggerMask = 0
std::string	fEqConfBuffer = "SYSTEM"
int	fEqConfType = 0
int	fEqConfSource = 0
std::string	fEqConfFormat = "MIDAS"
int	fEqConfReadOn = 0
int	fEqConfPeriodMilliSec = 1000
double	fEqConfEventLimit = 0
uint32_t	fEqConfNumSubEvents = 0
int	fEqConfLogHistory = 0
bool	fEqConfHidden = false
int	fEqConfWriteCacheSize = 10000000
bool	fEqConfReadOnlyWhenRunning = true
bool	fEqConfWriteEventsToOdb = false
double	fEqConfPeriodStatisticsSec = 1.0
double	fEqConfPollSleepSec = 0.000100
size_t	fEqConfMaxEventSize = 0
size_t	fEqConfBufferSize = 0
std::mutex	fEqMutex
TMFE *	fMfe = NULL
TMFrontend *	fFe = NULL
MVOdb *	fOdbEq = NULL
	ODB Equipment/EQNAME.
MVOdb *	fOdbEqCommon = NULL
	ODB Equipment/EQNAME/Common.
MVOdb *	fOdbEqSettings = NULL
	ODB Equipment/EQNAME/Settings.
MVOdb *	fOdbEqVariables = NULL
	ODB Equipment/EQNAME/Variables.
MVOdb *	fOdbEqStatistics = NULL
	ODB Equipment/EQNAME/Statistics.
TMEventBuffer *	fEqEventBuffer = NULL
int	fEqSerial = 0
double	fEqStatEvents = 0
double	fEqStatBytes = 0
double	fEqStatEpS = 0
double	fEqStatKBpS = 0
double	fEqStatLastTime = 0
double	fEqStatLastEvents = 0
double	fEqStatLastBytes = 0
double	fEqStatLastWrite = 0
double	fEqStatNextWrite = 0
double	fEqPeriodicLastCallTime = 0
double	fEqPeriodicNextCallTime = 0
std::atomic_bool	fEqPollThreadStarting {false}
std::atomic_bool	fEqPollThreadRunning {false}
std::atomic_bool	fEqPollThreadShutdownRequested {false}
std::thread *	fEqPollThread = NULL
std::string	fName
TMFeCommon *	fCommon
int	fBufferHandle
int	fSerial
double	fStatEvents
double	fStatBytes
double	fStatEpS
double	fStatKBpS
double	fStatLastTime
double	fStatLastEvents
double	fStatLastBytes

Detailed Description

Definition at line 17 of file tmfe_example_everything.cxx.

Constructor & Destructor Documentation

EqEverything()

EqEverything::EqEverything ( const char *  eqname, const char *  eqfilename  )

inline

Definition at line 21 of file tmfe_example_everything.cxx.

      : TMFeEquipment(eqname, eqfilename)
   {
      printf("EqEverything::ctor!\n");
 
      // configure the equipment here:
      
      //fEqConfReadConfigFromOdb = false;
      fEqConfEventID = 1;
      fEqConfPeriodMilliSec = 1000;
      fEqConfLogHistory = 1;
      fEqConfWriteEventsToOdb = true;
      fEqConfEnablePoll = true; // enable polled equipment
      //fEqConfPollSleepSec = 0; // to create a "100% CPU busy" polling loop, set poll sleep time to zero 
   }

~EqEverything()

EqEverything::~EqEverything ( )

inline

Definition at line 37 of file tmfe_example_everything.cxx.

   {
      printf("EqEverything::dtor!\n");
   }

Member Function Documentation

HandleBeginRun()

TMFeResult EqEverything::HandleBeginRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 92 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandleBeginRun", "Begin run %d!", run_number);
      EqSetStatus("Running", "#00FF00");
      return TMFeOk();
   }

Here is the call graph for this function:

HandleBinaryRpc()

TMFeResult EqEverything::HandleBinaryRpc ( const char *  cmd, const char *  args, std::vector< char > &  response  )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 73 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandleBinaryRpc", "Binary RPC cmd [%s], args [%s]", cmd, args);
 
      // RPC handler
      
      response.resize(8*64);
 
      uint64_t* p64 = (uint64_t*)response.data();
      uint64_t one = 1;
 
      for (size_t i=0; i<response.size()/sizeof(p64[0]); i++) {
         *p64++ = (one<<i);
      }
      
      return TMFeOk();
   }

Here is the call graph for this function:

HandleEndRun()

TMFeResult EqEverything::HandleEndRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 99 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandleEndRun", "End run %d!", run_number);
      EqSetStatus("Stopped", "#FFFFFF");
      return TMFeOk();
   }

Here is the call graph for this function:

HandleInit()

TMFeResult EqEverything::HandleInit ( const std::vector< std::string > &  args )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 47 of file tmfe_example_everything.cxx.

   {
      printf("EqEverything::HandleInit!\n");
      fMfe->RegisterTransitionStartAbort();
      fEqConfReadOnlyWhenRunning = false; // overwrite ODB Common RO_RUNNING to false
      fEqConfWriteEventsToOdb = true; // overwrite ODB Common RO_ODB to true
      EqSetStatus("Started...", "white");
      //EqStartPollThread();
      return TMFeOk();
   }

Here is the call graph for this function:

HandlePauseRun()

TMFeResult EqEverything::HandlePauseRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 106 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandlePauseRun", "Pause run %d!", run_number);
      EqSetStatus("Paused", "#FFFF00");
      return TMFeOk();
   }

Here is the call graph for this function:

HandlePeriodic()

void EqEverything::HandlePeriodic ( )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 140 of file tmfe_example_everything.cxx.

   {
      printf("EqEverything::HandlePeriodic!\n");
      double t = TMFE::GetTime();
      double data = 100.0*sin(0*M_PI/2.0+M_PI*t/40);
      SendData(data);
      char status_buf[256];
      snprintf(status_buf, sizeof(status_buf), "value %.1f", data);
      EqSetStatus(status_buf, "#00FF00");
   }

Here is the call graph for this function:

HandlePoll()

bool EqEverything::HandlePoll ( )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 151 of file tmfe_example_everything.cxx.

   {
      //printf("EqEverything::HandlePoll!\n");
 
      if (!fMfe->fStateRunning) // only poll when running
         return false;
 
      double r = drand48();
      if (r > 0.999) {
         // return successful poll rarely
         printf("EqEverything::HandlePoll!\n");
         return true;
      }
 
      return false;
   }

HandlePollRead()

void EqEverything::HandlePollRead ( )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 168 of file tmfe_example_everything.cxx.

   {
      printf("EqEverything::HandlePollRead!\n");
 
         char buf[1024];
 
         ComposeEvent(buf, sizeof(buf));
         BkInit(buf, sizeof(buf));
         
         uint32_t* ptr = (uint32_t*)BkOpen(buf, "poll", TID_UINT32);
         for (int i=0; i<16; i++) {
            *ptr++ = lrand48();
         }
         BkClose(buf, ptr);
         
         EqSendEvent(buf, false); // do not write polled data to ODB and history
   }

Here is the call graph for this function:

HandleResumeRun()

TMFeResult EqEverything::HandleResumeRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 113 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandleResumeRun", "Resume run %d!", run_number);
      EqSetStatus("Running", "#00FF00");
      return TMFeOk();
   }

Here is the call graph for this function:

HandleRpc()

TMFeResult EqEverything::HandleRpc ( const char *  cmd, const char *  args, std::string &  response  )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 58 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandleRpc", "RPC cmd [%s], args [%s]", cmd, args);
 
      // RPC handler
      
      char tmp[256];
      time_t now = time(NULL);
      snprintf(tmp, sizeof(tmp), "{ \"current_time\" : [ %d, \"%s\"] }", (int)now, ctime(&now));
      
      response = tmp;
 
      return TMFeOk();
   }

Here is the call graph for this function:

HandleStartAbortRun()

TMFeResult EqEverything::HandleStartAbortRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 120 of file tmfe_example_everything.cxx.

   {
      fMfe->Msg(MINFO, "HandleStartAbortRun", "Begin run %d aborted!", run_number);
      EqSetStatus("Stopped", "#FFFFFF");
      return TMFeOk();
   }

Here is the call graph for this function:

HandleUsage()

void EqEverything::HandleUsage ( )

inlinevirtual

Reimplemented from TMFeEquipment.

Definition at line 42 of file tmfe_example_everything.cxx.

   {
      printf("EqEverything::HandleUsage!\n");
   }

SendData()

void EqEverything::SendData ( double  dvalue )

inline

Definition at line 127 of file tmfe_example_everything.cxx.

   {
      char buf[1024];
      ComposeEvent(buf, sizeof(buf));
      BkInit(buf, sizeof(buf));
         
      double* ptr = (double*)BkOpen(buf, "data", TID_DOUBLE);
      *ptr++ = dvalue;
      BkClose(buf, ptr);
 
      EqSendEvent(buf);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• progs/tmfe_example_everything.cxx