Line data    Source code

       1              : //
       2              : // tmfe_example_multithread.cxx
       3              : //
       4              : // Example tmfe multithreaded c++ frontend
       5              : //
       6              : 
       7              : #include <stdio.h>
       8              : #include <signal.h> // SIGPIPE
       9              : #include <assert.h> // assert()
      10              : #include <stdlib.h> // malloc()
      11              : #include <unistd.h> // sleep()
      12              : #include <math.h> // M_PI
      13              : 
      14              : #include "midas.h"
      15              : #include "tmfe.h"
      16              : 
      17              : class Myfe :
      18              :    public TMFeEquipment
      19              : {
      20              : public:
      21            0 :    Myfe(const char* eqname, const char* eqfilename) // ctor
      22            0 :       : TMFeEquipment(eqname, eqfilename)
      23              :    {
      24            0 :    }
      25              : 
      26            0 :    ~Myfe() // dtor
      27            0 :    {
      28            0 :    }
      29              : 
      30            0 :    void SendData(double dvalue)
      31              :    {
      32              :       char buf[1024];
      33            0 :       ComposeEvent(buf, sizeof(buf));
      34            0 :       BkInit(buf, sizeof(buf));
      35              :          
      36            0 :       double* ptr = (double*)BkOpen(buf, "test", TID_DOUBLE);
      37            0 :       *ptr++ = dvalue;
      38            0 :       BkClose(buf, ptr);
      39              : 
      40            0 :       EqSendEvent(buf);
      41            0 :    }
      42              : 
      43            0 :    TMFeResult HandleRpc(const char* cmd, const char* args, std::string& response)
      44              :    {
      45            0 :       fMfe->Msg(MINFO, "HandleRpc", "Thread %s, RPC cmd [%s], args [%s]", TMFE::GetThreadId().c_str(), cmd, args);
      46            0 :       return TMFeOk();
      47              :    }
      48              : 
      49            0 :    TMFeResult HandleBeginRun(int run_number)
      50              :    {
      51            0 :       fMfe->Msg(MINFO, "HandleBeginRun", "Thread %s, Begin run %d!", TMFE::GetThreadId().c_str(), run_number);
      52            0 :       EqSetStatus("Running", "#00FF00");
      53            0 :       return TMFeOk();
      54              :    }
      55              : 
      56            0 :    TMFeResult HandleEndRun(int run_number)
      57              :    {
      58            0 :       fMfe->Msg(MINFO, "HandleEndRun", "Thread %s, End run %d!", TMFE::GetThreadId().c_str(), run_number);
      59            0 :       EqSetStatus("Stopped", "#00FF00");
      60            0 :       return TMFeOk();
      61              :    }
      62              : 
      63              :    //TMFeResult HandleStartAbortRun(int run_number)
      64              :    //{
      65              :    //   fMfe->Msg(MINFO, "HandleStartAbortRun", "Begin run %d aborted!", run_number);
      66              :    //   EqSetStatus("Stopped", "#00FF00");
      67              :    //   return TMFeOk();
      68              :    //}
      69              : 
      70            0 :    void HandlePeriodic()
      71              :    {
      72            0 :       printf("Thread %s, periodic!\n", TMFE::GetThreadId().c_str());
      73            0 :       double t = TMFE::GetTime();
      74            0 :       double data = 100.0*sin(M_PI/2.0+M_PI*t/60);
      75            0 :       SendData(data);
      76            0 :       fOdbEqVariables->WD("data", data);
      77              :       char status_buf[256];
      78            0 :       sprintf(status_buf, "value %.1f", data);
      79            0 :       EqSetStatus(status_buf, "#00FF00");
      80            0 :    }
      81              : };
      82              : 
      83            0 : static void usage()
      84              : {
      85            0 :    fprintf(stderr, "Usage: tmfe_example_mt ...\n");
      86            0 :    exit(1);
      87              : }
      88              : 
      89            0 : int main(int argc, char* argv[])
      90              : {
      91            0 :    setbuf(stdout, NULL);
      92            0 :    setbuf(stderr, NULL);
      93              : 
      94            0 :    signal(SIGPIPE, SIG_IGN);
      95              : 
      96            0 :    std::vector<std::string> eq_args;
      97              : 
      98              :    //std::string name = "";
      99              :    //
     100              :    //if (argc == 2) {
     101              :    //   name = argv[1];
     102              :    //} else {
     103              :    //   usage(); // DOES NOT RETURN
     104              :    //}
     105              : 
     106            0 :    TMFE* mfe = TMFE::Instance();
     107              : 
     108            0 :    TMFeResult result = mfe->Connect("tmfe_example_mt", __FILE__);
     109            0 :    if (result.error_flag) {
     110            0 :       fprintf(stderr, "Cannot connect to MIDAS, error \"%s\", bye.\n", result.error_message.c_str());
     111            0 :       return 1;
     112              :    }
     113              : 
     114              :    //mfe->SetWatchdogSec(0);
     115              : 
     116            0 :    TMFeEquipment* eq = new Myfe("tmfe_example_mt", __FILE__);
     117            0 :    eq->fEqConfEventID = 1;
     118            0 :    eq->fEqConfLogHistory = 1;
     119            0 :    eq->fEqConfPeriodMilliSec = 1000; // milliseconds
     120            0 :    eq->fEqConfBuffer = "SYSTEM";
     121              : 
     122            0 :    eq->EqInit(eq_args);
     123            0 :    eq->EqSetStatus("Starting...", "white");
     124              : 
     125            0 :    mfe->AddRpcHandler(eq);
     126              : 
     127              :    //mfe->SetTransitionSequenceStart(910);
     128              :    //mfe->SetTransitionSequenceStop(90);
     129              : 
     130              :    //mfe->DeregisterTransitionPause();
     131              :    //mfe->DeregisterTransitionResume();
     132              : 
     133              :    //mfe->RegisterTransitionStartAbort();
     134              : 
     135            0 :    printf("Main thread is %s\n", TMFE::GetThreadId().c_str());
     136              : 
     137            0 :    mfe->StartRpcThread();
     138              :    //mfe->StartPeriodicThread();
     139              : 
     140            0 :    eq->EqSetStatus("Started...", "white");
     141              : 
     142            0 :    while (!mfe->fShutdownRequested) {
     143            0 :       ::sleep(1);
     144              :    }
     145              : 
     146            0 :    mfe->Disconnect();
     147              : 
     148            0 :    return 0;
     149            0 : }
     150              : 
     151              : /* emacs
     152              :  * Local Variables:
     153              :  * tab-width: 8
     154              :  * c-basic-offset: 3
     155              :  * indent-tabs-mode: nil
     156              :  * End:
     157              :  */