crfe.cxx

Go to the documentation of this file.

/********************************************************************\
 
  Name:         crfe.cxx
  Created by:   Stefan Ritt
 
  Contents:     Code for modern slow control front-end "Clock and Reset"
                to illustrate manual generation of slow control
                events and hardware updates via cm_watch().
 
                The values of
 
                /Equipment/Clock Reset/Settings/Active
                /Equipment/Clock Reset/Settings/Delay
 
                are propagated to hardware when the ODB value chanes.
 
                The triggers
 
                /Equipment/Clock Reset/Settings/Reset Trigger
                /Equipment/Clock Reset/Settings/Sync Trigger
 
                can be set to TRUE to trigger a specific action
                in this front-end.
 
                For a real program, the "TODO" lines have to be 
                replaced by actual hardware acces.
 
                Custom page
                -----------
 
                The custom page "cr.html" in this directory can be
                used to control the settins of this frontend. To
                do so, set "/Custom/Path" in the ODB to this 
                directory and create a string
 
                /Custom/Clock Reset = cr.html
 
                then click on "Clock Reset" on the left lower corner
                in the web status page.
 
\********************************************************************/
 
#include <stdio.h>
#include <assert.h>
#include "midas.h"
#include "mfe.h"
 
/*-- Globals -------------------------------------------------------*/
 
/* The frontend name (client name) as seen by other MIDAS clients   */
const char *frontend_name = "CR Frontend";
/* The frontend file name, don't change it */
const char *frontend_file_name = __FILE__;
 
/* frontend_loop is called periodically if this variable is TRUE    */
BOOL frontend_call_loop = FALSE;
 
/* a frontend status page is displayed with this frequency in ms    */
INT display_period = 1000;
 
/* maximum event size produced by this frontend */
INT max_event_size = 10000;
 
/* maximum event size for fragmented events (EQ_FRAGMENTED) */
INT max_event_size_frag = 5 * 1024 * 1024;
 
/* buffer size to hold events */
INT event_buffer_size = 10 * 10000;
 
/*-- Function declarations -----------------------------------------*/
 
INT read_cr_event(char *pevent, INT off);
void cr_settings_changed(HNDLE, HNDLE, int, void *);
 
/*-- Equipment list ------------------------------------------------*/
 
BOOL equipment_common_overwrite = TRUE;
 
/* Default values for /Equipment/Clock Reset/Settings */
const char *cr_settings_str[] = {
"Active = BOOL : 1",
"Delay = INT : 0",
"Reset Trigger = BOOL : 0",
"Sync Trigger = BOOL : 0",
"Names CRT1 = STRING[4] :",
"[32] Temp0",
"[32] Temp1",
"[32] Temp2",
"[32] Temp3",
NULL
};
 
EQUIPMENT equipment[] = {
 
   {"Clock Reset",              /* equipment name */
    {10, 0,                     /* event ID, trigger mask */
     "SYSTEM",                  /* event buffer */
     EQ_PERIODIC,               /* equipment type */
     0,                         /* event source */
     "MIDAS",                   /* format */
     TRUE,                      /* enabled */
     RO_ALWAYS | RO_ODB,        /* read always and update ODB */
     10000,                     /* read every 10 sec */
     0,                         /* stop run after this event limit */
     0,                         /* number of sub events */
     1,                         /* log history every event */
     "", "", ""} ,
    read_cr_event,              /* readout routine */
   },
 
   {""}
};
 
 
/*-- Dummy routines ------------------------------------------------*/
 
INT poll_event(INT source, INT count, BOOL test)
{
   return 1;
};
 
INT interrupt_configure(INT cmd, INT source, POINTER_T adr)
{
   return 1;
};
 
/*-- Frontend Init -------------------------------------------------*/
 
INT frontend_init()
{
   HNDLE hKey;
 
   // create Settings structure in ODB
   db_create_record(hDB, 0, "Equipment/Clock Reset/Settings", strcomb1(cr_settings_str).c_str());
   db_find_key(hDB, 0, "/Equipment/Clock Reset", &hKey);
   assert(hKey);
 
   db_watch(hDB, hKey, cr_settings_changed, NULL);
 
   /*
    * Set our transition sequence. The default is 500. Setting it
    * to 600 means we are called AFTER most other clients.
    */
   cm_set_transition_sequence(TR_START, 600);
 
   return CM_SUCCESS;
}
 
/*-- Frontend Exit -------------------------------------------------*/
 
INT frontend_exit()
{
   return CM_SUCCESS;
}
 
/*-- Frontend Loop -------------------------------------------------*/
 
INT frontend_loop()
{
   return CM_SUCCESS;
}
 
/*-- Begin of Run --------------------------------------------------*/
 
#define N_READBACK 4
 
INT begin_of_run(INT run_number, char *error)
{
   /*
    * This example code starts a run transition, then waits on some
    * external conditions by polling an array in the ODB. It expects
    * that other programs set the readback array in the ODB to the
    * current run number
    */
 
   HNDLE hDB, hKey;
   INT readback[N_READBACK], i;
   cm_get_experiment_database(&hDB, nullptr);
 
   // set requested run number in ODB
   db_set_value(hDB, 0, "/Equipment/Clock Reset/Run transitions/Requested run number", &run_number, sizeof(INT), 1, TID_INT);
 
   // retrieve readback array form ODB
   int size = sizeof(readback);
   memset(readback, 0, size);
   db_find_key(hDB, 0, "/Equipment/Clock Reset/Run transitions/FEB readback", &hKey);
   if (!hKey) {
      // create readback array if not existing
      db_create_key(hDB, 0, "/Equipment/Clock Reset/Run transitions/FEB readback", TID_INT);
      db_find_key(hDB, 0, "/Equipment/Clock Reset/Run transitions/FEB readback", &hKey);
      db_set_data(hDB, hKey, readback, size, N_READBACK, TID_INT);
   }
 
   // set equipment status for status web page
   set_equipment_status("Clock Reset", "Waiting for readback", "yellowLight");
 
   // wait until readback succeeds
   int start_time = ss_time();
   do {
      db_get_data(hDB, hKey, readback, &size, TID_INT);
      for (i=0 ; i<N_READBACK ; i++) {
         if (readback[i] != run_number)
            break;
      }
      if (i == N_READBACK)
         break;
 
      // don't waste 100% CPU time
      ss_sleep(10);
 
   } while (ss_time() < start_time + 5); // wait maximal 5 seconds
 
   if (i < N_READBACK) {
      strcpy(error, "Timeout receiving FEB feedback");
      return FE_ERR_HW;
   }
 
   // set equipment status for status web page
   set_equipment_status("Clock Reset", "Ok", "greenLight");
 
   return CM_SUCCESS;
}
 
/*-- End of Run ----------------------------------------------------*/
 
INT end_of_run(INT run_number, char *error)
{
   return CM_SUCCESS;
}
 
/*-- Pause Run -----------------------------------------------------*/
 
INT pause_run(INT run_number, char *error)
{
   return CM_SUCCESS;
}
 
/*-- Resume Run ----------------------------------------------------*/
 
INT resume_run(INT run_number, char *error)
{
   return CM_SUCCESS;
}
 
/*--- Read Clock and Reset Event to be put into data stream --------*/
 
 /*
  *
 // example event to be directly injected into the stream
 struct EVENT {
   BANK_HEADER header;
   BANK32 bank;
   DWORD d1[4];
 };
 
 struct EVENT e = {
   { // BANK_HEADER
     sizeof(BANK32) + ALIGN8(4*sizeof(DWORD)),  // total size
     BANK_FORMAT_VERSION | BANK_FORMAT_32BIT    // flags
   },
   { // BANK32
     {'N', 'A', 'M', 'E'},  // bank name
     TID_DWORD,             // type
     4*sizeof(DWORD)        // data size
   },
   {  1, 2, 3, 4 }           // data
 };
 
 Inject event via -->
 
 INT read_cr_event(char *pevent, INT off)
 {
    memcpy(pevent, &e, sizeof(e));
    return bk_size(pevent);
 }
 */
 
INT read_cr_event(char *pevent, INT off)
{
   bk_init(pevent);
 
   float *pdata;
   bk_create(pevent, "CRT1", TID_FLOAT, (void **)&pdata);
 
   *pdata++ = (float) rand() / RAND_MAX;
   *pdata++ = (float) rand() / RAND_MAX;
   *pdata++ = (float) rand() / RAND_MAX;
   *pdata++ = (float) rand() / RAND_MAX;
 
   bk_close(pevent, pdata);
 
   return bk_size(pevent);
}
 
/*--- Called whenever settings have changed ------------------------*/
 
void cr_settings_changed(HNDLE hDB, HNDLE hKey, INT, void *)
{
   KEY key;
 
   db_get_key(hDB, hKey, &key);
 
   if (std::string(key.name) == "Active") {
      BOOL value;
      int size = sizeof(value);
      db_get_data(hDB, hKey, &value, &size, TID_BOOL);
      cm_msg(MINFO, "cr_settings_changed", "Set active to %d", value);
      // TODO: propagate to hardware
   }
 
   if (std::string(key.name) == "Delay") {
      INT value;
      int size = sizeof(value);
      db_get_data(hDB, hKey, &value, &size, TID_INT);
      cm_msg(MINFO, "cr_settings_changed", "Set delay to %d", value);
      // TODO: propagate to hardware
   }
 
   if (std::string(key.name) == "Reset Trigger") {
      BOOL value;
      int size = sizeof(value);
      db_get_data(hDB, hKey, &value, &size, TID_BOOL);
      if (value) {
         cm_msg(MINFO, "cr_settings_changed", "Execute reset");
         // TODO: propagate to hardware
         value = FALSE; // reset flag in ODB
         db_set_data(hDB, hKey, &value, sizeof(value), 1, TID_BOOL);
      }
   }
 
   if (std::string(key.name) == "Sync Trigger") {
      BOOL value;
      int size = sizeof(value);
      db_get_data(hDB, hKey, &value, &size, TID_BOOL);
      if (value) {
         cm_msg(MINFO, "cr_settings_changed", "Execute sync");
         // TODO: propagate to hardware
         value = FALSE; // reset flag in ODB
         db_set_data(hDB, hKey, &value, sizeof(value), 1, TID_BOOL);
      }
   }
}