hv_fug_scfe.c

Go to the documentation of this file.

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

  Name:         hv_fug_scfe.c
  Created by:   Andreas Suter

  Contents:     Midas frontend for the high voltage FUG devices

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

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

#include "midas.h"
#include "msystem.h"
#include "class/hv.h"
#include "hv_scs3000.h"
#include "bus/null.h"

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

char *frontend_name = "FUG";
char *frontend_file_name = __FILE__;

BOOL frontend_call_loop = TRUE;

INT display_period = 1000;

INT max_event_size = 10000;

INT max_event_size_frag = 5*1024*1024;

INT event_buffer_size = 10*10000;

// -- HV Monitoring Variables -----------------------------------------

#define LEMVAC_GAS_INLET_ON        0x80
#define LEMVAC_MC_STATUS_WORD_2    15
#define LEMVAC_TC_STATUS_WORD_2    18
#define LEMVAC_SC_STATUS_WORD_2    21

#define FUG_CHS                    16
#define FUG_READ_TIME              10
#define FUG_DEMAND_CHANGED_TIMEOUT 300
#define FUG_MC                     0
#define FUG_TC                     1
#define FUG_SC                     2

#define TD_FIRST_CH                0
#define TD_LAST_CH                 3
#define FUG_BEAMLINE_KV61_CH       28
#define FUG_BEAMLINE_KV62_CH       29

// detector rate
INT hv_fug_detector_rate;      

// Detector HV's
float *hv_detectors_measured;  

// keep handle to ODB
HNDLE hv_fug_hDB;
HNDLE hv_fug_measured_hKey;

// fug demand HV's
float hv_fug_demand[FUG_CHS];
// flag array telling which channel is belonging to which chamber
int hv_fug_chamber_flag[FUG_CHS];
// fug demand HV's changed timer
DWORD hv_fug_demand_changed_timer;
// fug demand <-> measured check timestamp
DWORD hv_fug_check_timestamp;
// fug demand HV drop counter
int hv_fug_drop_counter[FUG_CHS];

// debug flag, when enabled sending additional messages to the message system
int hv_fug_debug = 0;

// Monitoring stuff
INT  hv_fug_monitoring_enabled;    
char hv_fug_trip_rate_source[NAME_LENGTH]; 
INT  hv_fug_tripEnabled;           
INT  hv_fug_tripRate;              
INT  hv_fug_hvAlreadyOff;          

// Gas inlet stuff
float lemvac_in[27]; 

// FUG Monitoring default. Is used in case FUG Monitoring ODB structure is not in place yet.
const char *hv_fug_monitoring_str =
"FUG Monitoring = INT : 0\n\
Trip Rate Source = STRING : [32] TD\n\
Trip Enabled = INT : 1\n\
Trip Level = INT : 1500000\n\
";

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

DEVICE_DRIVER hv_driver[] = {
  { "hv_spin_rot", hv_scs3000,  4, null, DF_PRIO_DEVICE },
  { "hv_mc_tc",    hv_scs3000,  7, null, DF_PRIO_DEVICE },
  { "hv_sc",       hv_scs3000,  5, null, DF_PRIO_DEVICE }
};

EQUIPMENT equipment[] = {

  { "HV",                 // equipment name
   {72, 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
    30000,                // read every 30 sec
    0,                    // stop run after this event limit
    0,                    // number of sub events
    1,                    // log history every event
    "", "", "",},
    cd_hv_read,           // readout routine
    cd_hv,                // class driver main routine
    hv_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;};

//-- prototype declaration -----------------------------------------

void hv_fug_check_trip_level(INT, INT, void *);

// -- HV monitoring routines ---------------------------------------
void hv_fug_trip_rate_source_changed(INT hDB, INT hKey, void *dummy)
{
  INT  status;
  char str[128];
  char svalue[NAME_LENGTH];

  if (strstr(hv_fug_trip_rate_source, "TD")) { // rate switched to TD

    // close MCP1 rate hotlink
    strcpy(str, "/Equipment/Scaler/Variables/RATE/MCP1");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't find %s", str);
      return;
    }
    db_close_record(hDB, hKey);

    // establish TD rate hotlink
    strcpy(str, "/Equipment/Scaler/Variables/RATE/TD");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't find %s", str);
      return;
    }
    status = db_open_record(hDB, hKey, &hv_fug_detector_rate, sizeof(hv_fug_detector_rate),
                            MODE_READ, &hv_fug_check_trip_level, NULL);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
      return;
    }

    // message that the rates where switched to TD
    cm_msg(MINFO, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Switched to the TD rate for the HV trip monitoring");

  } else if (strstr(hv_fug_trip_rate_source, "MCP1")) { // rate switched to MCP1

    // close TD rate hotlink
    strcpy(str, "/Equipment/Scaler/Variables/RATE/TD");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't find %s", str);
      return;
    }
    db_close_record(hDB, hKey);

    // establish MCP1 rate hotlink
    strcpy(str, "/Equipment/Scaler/Variables/RATE/MCP1");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't find %s", str);
      return;
    }
    status = db_open_record(hDB, hKey, &hv_fug_detector_rate, sizeof(hv_fug_detector_rate),
                            MODE_READ, &hv_fug_check_trip_level, NULL);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
      return;
    }

    // message that the rates where switched to MCP1
    cm_msg(MINFO, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Switched to the MCP1 rate for the HV trip monitoring");

  } else { // garbage hence will set hv_fug_trip_rate_source to TD
    cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: %s not allowed, will switch to TD", hv_fug_trip_rate_source);
    strcpy(str, "/Equipment/HV/Monitoring/Trip Rate Source");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_trip_rate_source_changed", "hv_fug_scfe: Couldn't find %s", str);
      return;
    }
    strcpy(svalue, "TD");
    db_set_data(hDB, hKey, svalue, sizeof(svalue), 1, TID_STRING);
  }
}

//------------------------------------------------------------------
void hv_fug_check_trip_level(INT hDB, INT hKey, void *hv)
{
  char  str[128];
  INT   status, size, i, run_state;
  float value;
  float hv_demand_value[FUG_CHS];
  HNDLE demandKey, runStateKey;
  KEY   key;

  if (!hv_fug_tripEnabled) // trip monitoring not enabled, hence do nothing
    return;

  if (hv_fug_detector_rate > hv_fug_tripRate) { // measured TD/MCP1 rate larger than the trip level
    strcpy(str, "/Equipment/HV/Variables/Demand");
    status = db_find_key(hDB, 0, str, &demandKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_check_trip_level", "Couldn't find %s", str);
      return;
    }
    status = db_get_key(hDB, demandKey, &key);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_check_trip_level", "Couldn't get key info of %s", str);
      return;
    }
    // check if already tripped
    size = sizeof(hv_demand_value);
    db_get_data(hDB, demandKey, &hv_demand_value, &size, TID_FLOAT);
    for (i=0; i < key.num_values; i++) {
      if (hv_demand_value[i] != 0)
        break;
    }

    if (i<key.num_values) { // at least one demand value != 0
      // set all demand values to zero
      value = 0.f;
      for (i=0; i < key.num_values; i++)
        db_set_data_index(hDB, demandKey, &value, sizeof(value), i, TID_FLOAT);

      if (strstr(hv_fug_trip_rate_source, "TD")) // TD
        sprintf(str, "HV tripped due to too high rate (TD=%d/trip level=%d)",
                hv_fug_detector_rate, hv_fug_tripRate);
      else // MCP1
        sprintf(str, "HV tripped due to too high rate (MCP1=%d/trip level=%d)",
                hv_fug_detector_rate, hv_fug_tripRate);

      cm_msg(MERROR, "hv_fug_check_trip_level", str);

      al_trigger_alarm( "hv_fug_check_trip_level", str, "Warning", "High Voltage tripped. Will also close KV61, KV62!", AT_INTERNAL);

      // check if a run is active, and if yes pause it ----------------------------

      // get the run state and check if a run is active
      strcpy(str, "/Runinfo/State");
      status = db_find_key(hDB, 0, str, &runStateKey);
      if (status != DB_SUCCESS) {
        cm_msg(MERROR, "hv_fug_check_trip_level", "Couldn't find %s", str);
        return;
      }
      size = sizeof(run_state);
      db_get_data(hDB, runStateKey, &run_state, &size, TID_INT);
      if (run_state == STATE_RUNNING) {
        // pause the run
        status = cm_transition(TR_PAUSE, 0, str, sizeof(str), TR_SYNC, 0);
        if (status != CM_SUCCESS) {
          cm_msg(MERROR, "hv_fug_check_trip_level", "%s", str);
        }
      }

      // close KV61, KV62
      // get the demand array of the beamline frontend
      strcpy(str, "/Equipment/Beamline/Variables/Demand");
      status = db_find_key(hDB, 0, str, &demandKey);
      if (status != DB_SUCCESS) {
        cm_msg(MERROR, "hv_fug_check_trip_level", "Couldn't find %s", str);
        return;
      }
      // close KV61
      value = 0.0;
      db_set_data_index(hDB, demandKey, &value, sizeof(value), FUG_BEAMLINE_KV61_CH, TID_FLOAT);
      // close KV62
      value = 0.0;
      db_set_data_index(hDB, demandKey, &value, sizeof(value), FUG_BEAMLINE_KV62_CH, TID_FLOAT);
    }
  }
}

//------------------------------------------------------------------
void hv_fug_scfe_monitoring(INT hDB, INT hKey, void *hv)
{
  int    i;
  int    trip = FALSE;
  int    status;
  HNDLE  demandKey;
  KEY    key;
  char   str[128];
  float  value;
  float *hv_measured;

  // check if HV monitoring is enabled
  if (!hv_fug_monitoring_enabled)
    return;

  hv_measured = (float *)hv;

  // check if TD HV is too small
  for (i=TD_FIRST_CH; i<TD_LAST_CH; i++) {
    if (fabs(hv_measured[i]) < 0.1f) { // i.e. smaller 100V
      trip = TRUE;
      break;
    }
  }

  if (!trip) // if TD HV are set
    hv_fug_hvAlreadyOff = FALSE;

  // at least on TD HV < 100V and not already tripped
  if (trip && !hv_fug_hvAlreadyOff) {
    hv_fug_hvAlreadyOff = TRUE;
    cm_msg(MERROR, "hv_fug_scfe_monitoring", "TD HV off!! Will switch off all HV :-(");
    strcpy(str, "/Equipment/HV/Variables/Demand");
    status = db_find_key(hDB, 0, str, &demandKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_scfe_monitoring", "Couldn't find %s", str);
      return;
    }
    status = db_get_key(hDB, demandKey, &key);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_scfe_monitoring", "Couldn't get key info of %s", str);
      return;
    }
    value = 0.f;
    for (i=0; i < key.num_values; i++)
      db_set_data_index(hDB, demandKey, &value, sizeof(value), i, TID_FLOAT);
  }
}

//------------------------------------------------------------------
void hv_fug_scfe_gas_inlet(INT hDB, INT hKey, void *dummy)
{
  char  str[128];
  int   status, i, ival;
  float value;
  HNDLE fug_hKey;

  // check moderator chamber
  ival = (int)lemvac_in[LEMVAC_MC_STATUS_WORD_2];
  if (ival & LEMVAC_GAS_INLET_ON) {
    // get FUG hv demand odb key
    strcpy(str, "/Equipment/HV/Variables/Demand");
    status = db_find_key(hDB, 0, str, &fug_hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_scfe_gas_inlet", "Couldn't find %s", str);
      return;
    }

    // set all hv values of the moderator chamber (Moderator, Mod_Guard, Mod_Grid, Lense_1, Mirror) to zero
    value = 0.0;
    for (i=0; i<FUG_CHS; i++) {
      if (hv_fug_chamber_flag[i] == FUG_MC)
        db_set_data_index(hDB, fug_hKey, &value, sizeof(value), i, TID_FLOAT);
    }
  }

  // check trigger chamber
  ival = (int)lemvac_in[LEMVAC_TC_STATUS_WORD_2];
  if (ival & LEMVAC_GAS_INLET_ON) {
    // get FUG hv demand odb key
    strcpy(str, "/Equipment/HV/Variables/Demand");
    status = db_find_key(hDB, 0, str, &fug_hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_scfe_gas_inlet", "Couldn't find %s", str);
      return;
    }

    // set all hv values of the trigger chamber (Lense_2, Lense_3) to zero
    value = 0.0;
    for (i=0; i<FUG_CHS; i++) {
      if (hv_fug_chamber_flag[i] == FUG_TC)
        db_set_data_index(hDB, fug_hKey, &value, sizeof(value), i, TID_FLOAT);
    }
  }

  // check sample chamber
  ival = (int)lemvac_in[LEMVAC_SC_STATUS_WORD_2];
  if (ival & LEMVAC_GAS_INLET_ON) {
    // get FUG hv demand odb key
    strcpy(str, "/Equipment/HV/Variables/Demand");
    status = db_find_key(hDB, 0, str, &fug_hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hv_fug_scfe_gas_inlet", "Couldn't find %s", str);
      return;
    }

    // set all hv values of the sample chamber (RA-L, RA-R, RA-T, RA-B, Sample) to zero
    value = 0.0;
    for (i=0; i<FUG_CHS; i++) {
      if (hv_fug_chamber_flag[i] == FUG_SC)
        db_set_data_index(hDB, fug_hKey, &value, sizeof(value), i, TID_FLOAT);
    }
  }
}

//------------------------------------------------------------------
void hv_fug_demand_changed(INT hDB, INT hKey, void *dummy)
{
  hv_fug_demand_changed_timer = ss_time();
}

//-- Frontend Init -------------------------------------------------
INT frontend_init()
{
  HNDLE hDB, hKey;
  KEY   keyInfo;
  INT   status, i;
  char  str[128];

  // 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);

  // fill the FUG chamber flag array
  hv_fug_chamber_flag[0]  = FUG_TC; // Right rod of the spin rotator
  hv_fug_chamber_flag[1]  = FUG_TC; // Left rod of the spin rotator
  hv_fug_chamber_flag[2]  = FUG_TC; // Left plate of the spin rotator
  hv_fug_chamber_flag[3]  = FUG_TC; // Right plate of the spin rotator
  hv_fug_chamber_flag[4]  = FUG_MC; // Moderator
  hv_fug_chamber_flag[5]  = FUG_MC; // Moderator guard
  hv_fug_chamber_flag[6]  = FUG_MC; // Moderator grid
  hv_fug_chamber_flag[7]  = FUG_MC; // Lense 1
  hv_fug_chamber_flag[8]  = FUG_MC; // Mirror
  hv_fug_chamber_flag[9]  = FUG_TC; // Lense 2
  hv_fug_chamber_flag[10] = FUG_TC; // Lense 3
  hv_fug_chamber_flag[11] = FUG_SC; // RA-L
  hv_fug_chamber_flag[12] = FUG_SC; // RA-R
  hv_fug_chamber_flag[13] = FUG_SC; // RA-T
  hv_fug_chamber_flag[14] = FUG_SC; // RA-B
  hv_fug_chamber_flag[15] = FUG_SC; // Sample


  // init global variables
  hv_fug_monitoring_enabled = FALSE;
  hv_fug_hvAlreadyOff       = FALSE;
  hv_detectors_measured     = NULL;
  hv_fug_demand_changed_timer = ss_time();

  // get ODB main handle
  cm_get_experiment_database(&hDB, NULL);

  // keep global handle
  hv_fug_hDB = hDB;

  // hotlink monitoring
  strcpy(str, "/Equipment/HV/Monitoring/FUG Monitoring");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MINFO, "frontend_init", "hv_fug_scfe: Couldn't find %s. Will try to generate it.", str);
    cm_yield(0);
    status = db_create_record(hDB, 0, "/Equipment/HV/Monitoring", hv_fug_monitoring_str);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "frontend_init", "hv_fug_scfe: **ERROR** Couldn't find %s", str);
      cm_yield(0);
      return CM_SUCCESS;
    }
    return CM_SUCCESS;
  }
  status = db_open_record(hDB, hKey, &hv_fug_monitoring_enabled, sizeof(hv_fug_monitoring_enabled),
                          MODE_READ, NULL, NULL);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
    return CM_SUCCESS;
  }

  // hotlink trip rate source: TD or MCP1
  strcpy(str, "/Equipment/HV/Monitoring/Trip Rate Source");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }
  status = db_open_record(hDB, hKey, &hv_fug_trip_rate_source, sizeof(hv_fug_trip_rate_source),
                          MODE_READ, &hv_fug_trip_rate_source_changed, NULL);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
    return CM_SUCCESS;
  }

  // hotlink trip enable flag
  strcpy(str, "/Equipment/HV/Monitoring/Trip Enabled");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }
  status = db_open_record(hDB, hKey, &hv_fug_tripEnabled, sizeof(hv_fug_tripEnabled),
                          MODE_READ, NULL, NULL);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
    return CM_SUCCESS;
  }

  // hotlink trip rate
  strcpy(str, "/Equipment/HV/Monitoring/Trip Level");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }
  status = db_open_record(hDB, hKey, &hv_fug_tripRate, sizeof(hv_fug_tripRate),
                          MODE_READ, NULL, NULL);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
    return CM_SUCCESS;
  }

  if (strstr(hv_fug_trip_rate_source, "TD")) { // hotlink TD rate
    cm_msg(MINFO, "frontend_init", "hv_fug_scfe: will used TD rate for HV rate monitoring");
    strcpy(str, "/Equipment/Scaler/Variables/RATE/TD");
  } else { // hotlink MCP1 rate
    cm_msg(MINFO, "frontend_init", "hv_fug_scfe: will used MCP1 rate for HV rate monitoring");
    strcpy(str, "/Equipment/Scaler/Variables/RATE/MCP1");
  }
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }
  status = db_open_record(hDB, hKey, &hv_fug_detector_rate, sizeof(hv_fug_detector_rate),
                          MODE_READ, &hv_fug_check_trip_level, NULL);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
    return CM_SUCCESS;
  }

  // hotlink Detector HV measured
  strcpy(str, "/Equipment/HV Detectors/Variables/Measured");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }
  status = db_get_key(hDB, hKey, &keyInfo);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't get key info of %s", str);
    return CM_SUCCESS;
  }

  hv_detectors_measured = (float *)calloc(keyInfo.num_values, sizeof(float));

  status = db_open_record(hDB, hKey, hv_detectors_measured,
                          keyInfo.num_values*sizeof(float),
                          MODE_READ, &hv_fug_scfe_monitoring, hv_detectors_measured);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't establish hotlink to %s", str);
    return CM_SUCCESS;
  }

  // keep measured key for cyclic reading in frontend loop
  strcpy(str, "/Equipment/HV/Variables/Measured");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }
  hv_fug_measured_hKey = hKey;

  // hotlink lemvac input variables needed to check the gas inlet state
  strcpy(str, "/Equipment/LEMVAC/Variables/Input");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }

  status = db_open_record(hDB, hKey, &lemvac_in, sizeof(lemvac_in), MODE_READ,
                          &hv_fug_scfe_gas_inlet, NULL);

  // hotlink FUG HV demand
  strcpy(str, "/Equipment/HV/Variables/Demand");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_init", "hv_fug_scfe: Couldn't find %s", str);
    return CM_SUCCESS;
  }

  status = db_open_record(hDB, hKey, &hv_fug_demand, sizeof(hv_fug_demand), MODE_READ,
                          &hv_fug_demand_changed, NULL);

  // init FUG HV demand <-> measured drop counter
  for (i=0; i<FUG_CHS; i++)
    hv_fug_drop_counter[i] = 0;

  // init FUG HV demand <-> measured read timer
  hv_fug_check_timestamp = ss_time();

  return CM_SUCCESS;
}

//-- Frontend Exit -------------------------------------------------
INT frontend_exit()
{
  char  str[128];
  int   status;
  HNDLE hDB, hKey;

  // get ODB main handle
  cm_get_experiment_database(&hDB, NULL);

  // unlink fug monitoring
  strcpy(str, "/Equipment/HV/Monitoring/FUG Monitoring");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink trip rate source
  strcpy(str, "/Equipment/HV/Monitoring/Trip Rate Source");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink trip enabled
  strcpy(str, "/Equipment/HV/Monitoring/Trip Enabled");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink trip level
  strcpy(str, "/Equipment/HV/Monitoring/Trip Level");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink TD/MCP1 rates
  if (strstr(hv_fug_trip_rate_source, "TD")) { // unlink TD rate
    strcpy(str, "/Equipment/Scaler/Variables/RATE/TD");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
      return CM_SUCCESS;
    }
    db_close_record(hDB, hKey);
  } else { // unlink MCP1 rate
    strcpy(str, "/Equipment/Scaler/Variables/RATE/MCP1");
    status = db_find_key(hDB, 0, str, &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
      return CM_SUCCESS;
    }
    db_close_record(hDB, hKey);
  }

  // unlink detector hv measured
  strcpy(str, "/Equipment/HV Detectors/Variables/Measured");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // free memory
  if (hv_detectors_measured)
    free(hv_detectors_measured);

  // unlink lemvac input
  strcpy(str, "/Equipment/LEMVAC/Variables/Input");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  // unlink FUG HV demand values
  strcpy(str, "/Equipment/HV/Variables/Demand");
  status = db_find_key(hDB, 0, str, &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "frontend_exit", "hv_fug_scfe: Couldn't find %s, status=%d", str, status);
    return CM_SUCCESS;
  }
  db_close_record(hDB, hKey);

  return CM_SUCCESS;
}

//-- Frontend Loop -------------------------------------------------
INT frontend_loop()
{
  HNDLE hKey;
  DWORD now;
  int   size, i;
  float measured[FUG_CHS];
  char  str[256];
  char  name[NAME_LENGTH];

  // check if FUG HV demand values just recently changed. If so, do nothing
  now = ss_time();
  if (now-hv_fug_demand_changed_timer<FUG_DEMAND_CHANGED_TIMEOUT) {
    return CM_SUCCESS;
  } else {
    if (hv_fug_debug)
      cm_msg(MINFO, "frontend_loop", "hv_fug_scfe: time to do something ...");  
  }  

  // check if FUG HV demand - FUG HV measured is within the tolerance
  // time to read hv measured?
  now = ss_time();
  if (now - hv_fug_check_timestamp > FUG_READ_TIME) {
    if (hv_fug_debug)
       cm_msg(MINFO, "frontend_loop", "hv_fug_scfe: will read hv measured");
    // reset timer
    hv_fug_check_timestamp = now;
    // read hv measured values from ODB
    size = sizeof(measured);
    db_get_record(hv_fug_hDB, hv_fug_measured_hKey, &measured[0], &size, 0);
    // check if measured one is deviating too strongly from the demand
    for (i=0; i<FUG_CHS; i++) {
      if ((hv_fug_demand[i] != 0.0) && (fabs(hv_fug_demand[i]-measured[i])>0.2)) {
        hv_fug_drop_counter[i]++;
        if (hv_fug_debug)
          cm_msg(MINFO, "frontend_loop", "hv_fug_scfe: ch = %d, drop counter = %d", i,  hv_fug_drop_counter[i]);
        // check of limit is reached
        if (hv_fug_drop_counter[i]>5) {
          // get name from ODB
          strcpy(str, "/Equipment/HV/Settings/Names");
          db_find_key(hv_fug_hDB, 0, str, &hKey);
          size = sizeof(name);
          db_get_data_index(hv_fug_hDB, hKey, name, &size, i, TID_STRING);
          sprintf(str, "HV FUG %s: measured = %f, demand = %f, check!!",
                       name, measured[i], hv_fug_demand[i]);
          al_trigger_alarm( "hv_fug_scfe", str, "Warning", str, AT_INTERNAL);
        }
      } else { // reset drop counter since readback is OK
        hv_fug_drop_counter[i]  = 0;
      }
    }
  }

  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;
}

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