beamline_scfe.c

Go to the documentation of this file.

/********************************************************************\

  Name:         beamline_scfe.c
  Created by:   Andreas Suter, 2013/04/10
                Thomas Prokscha, 2013/06/07: added checking of beamline devices

  Contents:     Midas frontend to operate the muE4 beamline via EPICS

\********************************************************************/

#include <stdio.h>
#include <string.h>
#include <math.h>

#include "midas.h"
#include "msystem.h"
#include "bus/tcpip.h"
#include "class/generic.h"
// #include "device/psi_epics.h"
#include "device/lem_epics.h"
#include "experim.h"

#define BL_CHANNELS          40  
#define BL_TOLERANCE       0.01  
#define BL_CHECK_MAX_COUNT    5

//-- Globals -------------------------------------------------------

char *frontend_name = "BeamLine SC";
char *frontend_file_name = __FILE__;

BOOL frontend_call_loop = FALSE;

INT display_period = 1000;

INT max_event_size = 10000;

INT max_event_size_frag = 5*1024*1024;

INT event_buffer_size = 10*10000;

BEAMLINE_SETTINGS   beamline_settings;
BEAMLINE_MONITORING beamline_monitoring; 
BEAMLINE_EVENT      beamline_event;
INT                 bl_check_counter[BL_CHANNELS]; 

//-- Equipment list ------------------------------------------------

DEVICE_DRIVER bl_driver[] = {
//   { "Beamline",   psi_epics,  BL_CHANNELS, tcpip, DF_PRIO_DEVICE },
  { "Beamline",   lem_epics,  BL_CHANNELS, tcpip, DF_PRIO_DEVICE },
  { "" }
};

EQUIPMENT equipment[] = {

  { "Beamline",           // equipment name
   {99, 0,                // event ID, trigger mask
    "SYSTEM",             // event buffer
    EQ_SLOW,              // equipment type
    0,                    // event source
    "FIXED",              // format
    TRUE,                 // enabled
    RO_RUNNING |
    RO_TRANSITIONS,       // read when running and on transitions
    60000,                // read every 60 sec
    0,                    // stop run after this event limit
    0,                    // number of sub events
    1,                    // log history every event
    "", "", "",},
    cd_gen_read,          // readout routine
    cd_gen,               // class driver main routine
    bl_driver,            // device driver list
    NULL,                 // init string
  },

  { "" }
};



//-- Dummy routines ------------------------------------------------

INT  poll_event(INT source[], INT count, BOOL test) {return 1;};
INT  interrupt_configure(INT cmd, INT source[], PTYPE adr) {return 1;};


/*-- Beamline checking routines -------------------------------------*/
/*
 * <p>Hot-link routine; shows the devices which are being checked
 *
 */
void bl_check_info(INT hDB, INT hKey, void *dummy)
{
 INT i;
 
 if (!beamline_monitoring.bl_checking){
    cm_msg(MINFO,"bl_check_info", "Checking of beamline devices disabled.");
    return;
 } 
 
 if (beamline_monitoring.bl_checking!=0)
    cm_msg(MINFO,"bl_check_info", "Checking of beamline devices enabled.");

 if (beamline_monitoring.bl_checking==2)
    cm_msg(MINFO,"bl_check_info", "Automatic switch-on of beamline devices enabled.");

 if (beamline_monitoring.bl_checking!=2)
    cm_msg(MINFO,"bl_check_info", "Automatic switch-on of beamline devices disabled.");
 
 for (i=0; i<BL_CHANNELS; i++){
   if (!beamline_monitoring.bl_channel_checking[i]) continue;
   cm_msg(MINFO,"bl_check_info", "Checking beamline device %s", beamline_settings.names[i]); 
 }
 return;
}


/*-- Beamline checking routine -------------------------------------*/
/*
 * <p>Hot-link routine; check beamline magnet supplies: compare Demand 
 *    with Measured values to detect if there is a problem with one of the 
 *    power supplies; 
 *    Send an error message, if error occurs BL_CHECK_MAX_COUNT times successivley.
 *    It can be disabled by setting
 *    /Equipment/Beamline/Monitoring/bl_checking = 0
 *
 */
void bl_check_devices(INT hDB, INT hKey, void *dummy)
{
 INT   i, status;
 float bl_deviation;
 char  alarm_message[128];
 char  cmd[256];
  
 if (!beamline_monitoring.bl_checking) 
   return;

 for ( i=0; i<BL_CHANNELS; i++){
   
   if (!beamline_monitoring.bl_channel_checking[i]) continue;
   
   bl_deviation = fabs(beamline_event.demand[i] - beamline_event.measured[i]);
   if (beamline_event.demand[i] != 0.0){
      if ( bl_deviation > BL_TOLERANCE*fabs(beamline_event.demand[i]) ||
           bl_deviation > BL_TOLERANCE*fabs(beamline_event.measured[i]))
           bl_check_counter[i]++;
      else
           bl_check_counter[i] = 0; //everything ok      
   }
   else
       bl_check_counter[i] = 0;
   
   if ( bl_check_counter[i] > BL_CHECK_MAX_COUNT ) {
     sprintf(alarm_message,"Problem with beamline device %s: Demand = %8f, Measured = %8.4f",
             beamline_settings.names[i], beamline_event.demand[i], beamline_event.measured[i]);
     al_trigger_alarm( "bl_check_devices", alarm_message,
                       "Warning", "BeamLine Magnets have to be checked!", AT_INTERNAL);
     if ((i<18 || i == 30) && beamline_monitoring.bl_checking==2) {//beam line magnet device, try to switch it on
       sprintf(cmd, "caput %s:COM:1 1", beamline_settings.names[i]);
       status = system(cmd);
       cm_msg(MINFO,"bl_check_devices","Try to turn on magnet device: cmd = %s",cmd);
//       cm_msg(MINFO,"frontend_init","Return status of cmd: %d", status);
       ss_sleep(2000);
     }
   }
 }// end loop over magnets
}
//-- Frontend Init -------------------------------------------------
INT frontend_init()
{
  HNDLE hDB, hKey;
  INT   size, i;
//  INT   status;
//  char  cmd[256];

  // de-register run-transition notifications
  cm_deregister_transition(TR_START);
  cm_deregister_transition(TR_STOP);
  cm_deregister_transition(TR_PAUSE);
  cm_deregister_transition(TR_RESUME);

  cm_get_experiment_database(&hDB, NULL);

  // get beamline settings record with device names
  size = sizeof(beamline_settings);
  db_find_key(hDB, 0, "/Equipment/Beamline/Settings", &hKey);
  
  if (db_get_record(hDB, hKey, &beamline_settings, &size, 0) != DB_SUCCESS){
    cm_msg(MERROR, "beamline_frontend_init", "Cannot get \"/Equipment/Beamline/Settings\" record in ODB");
    return CM_SUCCESS;
  }
  
  // get beamline monitoring record
  size = sizeof(beamline_monitoring);
  db_find_key(hDB, 0, "/Equipment/Beamline/Monitoring", &hKey);
  
  if (db_open_record(hDB, hKey, &beamline_monitoring, sizeof(beamline_monitoring),
      MODE_READ, bl_check_info,NULL) != DB_SUCCESS){
    cm_msg(MERROR, "beamline_frontend_init", "Cannot get \"/Equipment/Beamline/Monitoring\" record in ODB");
    return CM_SUCCESS;
  }
  
  // open ODB record hot-link to beamline device Demand and Measured values
  db_find_key(hDB, 0, "/Equipment/Beamline/Variables", &hKey);  
  
  if (db_open_record(hDB, hKey, &beamline_event, sizeof(beamline_event), 
      MODE_READ, bl_check_devices, NULL) != DB_SUCCESS){
    cm_msg(MERROR, "beamline_frontend_init", "Cannot open \"/Equipment/Beamline/Variables\" record in ODB");
    return CM_SUCCESS;
  }
  
  for (i=0; i<BL_CHANNELS; i++)
    bl_check_counter[i] = 0;
  
  if (beamline_monitoring.bl_checking!=0)
    cm_msg(MINFO,"beamline_frontend_init", "Checking of beamline devices enabled.");
  else{
    cm_msg(MINFO,"beamline_frontend_init", "Checking of beamline devices disabled.");
    return CM_SUCCESS;
  }
  if (beamline_monitoring.bl_checking==2)
    cm_msg(MINFO,"beamline_frontend_init", "Automatic switch-on of beamline devices enabled.");
  if (beamline_monitoring.bl_checking!=2)
    cm_msg(MINFO,"bl_check_info", "Automatic switch-on of beamline devices disabled.");

/*
    sprintf(cmd,"caput %s:COM:1 1", beamline_settings.names[0]);
    status = system(cmd);
    cm_msg(MINFO,"frontend_init","Try to turn on magnet device: cmd = %s",cmd);
    cm_msg(MINFO,"frontend_init","Return status of cmd: %d", status);
    ss_sleep(1000);
*/
  return CM_SUCCESS;
}

//-- Frontend Exit -------------------------------------------------
INT frontend_exit()
{
  return CM_SUCCESS;
}

//-- Frontend Loop -------------------------------------------------
INT frontend_loop()
{
  return CM_SUCCESS;
}

//-- Begin of Run --------------------------------------------------
INT begin_of_run(INT run_number, char *error)
{
  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;
}

//------------------------------------------------------------------