lemvac.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------

  Name:         lemvac.c
  Created by:   Andreas Suter  2004/08/30
  Rewritten by: Andreas Suter  2016/01/25 (new Siemens SPS communication modules)

  Contents:     device driver for the lem vacuum SPS control unit

----------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include "midas.h"
#include "lemvac.h"

#define LV_HV_NO_INTERLOCK_FLAG 128
#define LV_GAS_INLET_FLAG       128

// bits as encoded in the SPS words
#define LV_BIT0  0x0100
#define LV_BIT1  0x0200
#define LV_BIT2  0x0400
#define LV_BIT3  0x0800
#define LV_BIT4  0x1000
#define LV_BIT5  0x2000
#define LV_BIT6  0x4000
#define LV_BIT7  0x8000
#define LV_BIT8  0x0001
#define LV_BIT9  0x0002
#define LV_BIT10 0x0004
#define LV_BIT11 0x0008
#define LV_BIT12 0x0010
#define LV_BIT13 0x0020
#define LV_BIT14 0x0040
#define LV_BIT15 0x0080

// channels of the SPS input variables
#define LV_LIFESIGN 0
#define LV_MCGR     1
#define LV_MCGT     2
#define LV_MCGJ     3
#define LV_MCGJ2    4
#define LV_TCGR     5
#define LV_TCGT     6
#define LV_TCGJ     7
#define LV_TCGJ2    8
#define LV_SCGR     9
#define LV_SCGT     10
#define LV_SCGJ     11
#define LV_SCGJ2    12
#define LV_PZGR     13
#define LV_MCSTAT1  14
#define LV_MCSTAT2  15
#define LV_MCSTAT3  16
#define LV_TCSTAT1  17
#define LV_TCSTAT2  18
#define LV_TCSTAT3  19
#define LV_SCSTAT1  20
#define LV_SCSTAT2  21
#define LV_SCSTAT3  22
#define LV_PZSTAT1  23
#define LV_PZSTAT2  24
#define LV_BPVX     25
#define LV_BPVY     26

// channels of the SPS output variables
#define LV_BPVX_ENABLED        0
#define LV_BPVX_CMD            1
#define LV_BPVY_ENABLED        2
#define LV_BPVY_CMD            3
#define LV_SC_PUMP_CMD_ENABLED 4
#define LV_SC_PUMP_CMD         5
#define LV_SC_VENT_CMD_ENABLED 6
#define LV_SC_VENT_CMD         7

// BPVX/Y commands
#define LV_BPV_CMD_IDLE   0.0
#define LV_BPV_CMD_TOGGLE 1.0
#define LV_BPV_CMD_OPEN   2.0
#define LV_BPV_CMD_CLOSE  3.0

#define SPS_MAX_BYTES 680         
#define LEMVAC_TIME_CONST    0    
#define LEMVAC_TIMEOUT_ERROR 3600 

// flags needed the more complex commands like start/stop the pump and/or venting the SC
#define LEMVAC_SC_PENDING_CMD_IDLE 0
#define LEMVAC_SC_PENDING_CMD_STOP 1
#define LEMVAC_SC_PENDING_CMD_VENT 2

#define VENT_STATE_HV_BIT   0
#define VENT_STATE_TEMP_BIT 1
#define VENT_STATE_BPVY_BIT 2
#define VENT_STATE_PUMP_BIT 3

#define VENT_CMD_STOP  0
#define VENT_CMD_START 1

// ODB indices for the FUG's in the SC region
#define FUG_SC_RAL_IDX    11
#define FUG_SC_RAR_IDX    12
#define FUG_SC_RAT_IDX    13
#define FUG_SC_RAB_IDX    14
#define FUG_SC_SAMPLE_IDX 15

// ODB indices for the sample cryo relevant for venting
#define SAMPLE_IN_CF1_IDX        0
#define SAMPLE_OUT_SET_POINT_IDX 1
#define SAMPLE_OUT_LS_RAMP       7
#define SAMPLE_OUT_BH1_FLOW_IDX  8
#define SAMPLE_OUT_BH2_FLOW_IDX  10

typedef struct {
  INT detailed_msg; 
} LEMVAC_INTERN;

#define LAMVAC_INTERN_STR "\
Detailed Messages = INT : 0\n\
"

typedef struct {
char in_name[LEMVAC_IN_VARS][NAME_LENGTH];   
char out_name[LEMVAC_OUT_VARS][NAME_LENGTH]; 
} LEMVAC_NAMES;

#define LEMVAC_NAMES_STR "\
Input Names = STRING[27] : \n\
[32] Life Sign\n\
[32] MC_GR Pirani\n\
[32] MC_GT Pirani\n\
[32] MC_GJ Penning\n\
[32] MC_GJ2 Penning\n\
[32] TC_GR Pirani\n\
[32] TC_GT Pirani\n\
[32] TC_GJ Penning\n\
[32] TC_GJ2 Penning\n\
[32] SC_GR Pirani\n\
[32] SC_GT Pirani\n\
[32] SC_GJ Penning\n\
[32] SC_GJ2 Penning\n\
[32] PZ_GR Pirani\n\
[32] MC Status Word 1\n\
[32] MC Status Word 2\n\
[32] MC Status Word 3\n\
[32] TC Status Word 1\n\
[32] TC Status Word 2\n\
[32] TC Status Word 3\n\
[32] SC Status Word 1\n\
[32] SC Status Word 2\n\
[32] SC Status Word 3\n\
[32] PZ Status Word 1\n\
[32] PZ Status Word 2\n\
[32] BPVX Status Word\n\
[32] BPVY Status Word\n\
Output Names = STRING[8] : \n\
[32] BPVX enabled\n\
[32] BPVX toggle cmd\n\
[32] BPVY enabled\n\
[32] BPVY toggle cmd\n\
[32] SC pump cmd enabled\n\
[32] SC pump cmd\n\
[32] SC vent enabled\n\
[32] SC vent cmd\n\
"

typedef struct {
  LEMVAC_INTERN intern;        
  LEMVAC_NAMES lemvac_names;   
  char lemvac_buffer[SPS_MAX_BYTES]; 
  float lemvac_data[LEMVAC_IN_VARS];  
  INT (*bd)(INT cmd, ...);     
  void *bd_info;               
  int   bpv_enabled[2];        
  int   sc_pump_cmd_enabled;   
  int   sc_vent_cmd_enabled;   
  char  handshake_cmd[32];     
  int   handshake_err_count[4]; 
  HNDLE hDB;                   
  HNDLE hKey_in;               
  HNDLE hKey_out;              
  HNDLE hKey_DB_Buffer;        
  DWORD time;                  
  DWORD errTime;               
  INT   startup_error;         
  INT   tcpip_open_error;      
  INT   read_error;            
  INT   read_counts;           
  DWORD last_success;          
} LEMVAC_INFO;

LEMVAC_INFO *gInfo; 

// lemvac_sc_vent_state keeps the current state of the sample chamber. It is
// encoded the following way:
// XXX0 : HV on (HV's in the sample chamber)
// XXX1 : HV off
// XX0X : T<90K (CF1 of the sample cryo)
// XX1X : T>=90K
// X0XX : BPVY open
// X1XX : BPVY closed
// 0XXX : sample chamber pumping station is off
// 1XXX : sample chamber pumping station is on
//
// this means lemvac_sc_vent_state = 15 (1111 binary) is needed that the sample chamber can be vented.
INT lemvac_sc_vent_state;

// 0: idle
// 1: stop SC pump
// 2: vent SC
INT lemvac_pending_sc_cmd;

void lemvac_write_cmd(LEMVAC_INFO *info);
void lemvac_stop_sc_pump(LEMVAC_INFO *info);
void lemvac_vent_sc(LEMVAC_INFO *info, INT cmd);
void lemvac_set_sliding_valve(LEMVAC_INFO *info, INT valve, float value);

//------------------------------------------------------------------------
INT lemvac_check_sample_hv()
{
  INT state = 0;
  INT status, i;
  HNDLE hDB, hKey;
  INT size;
  float fval;

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

  // get FUG frontend key
  status = db_find_key(hDB, 0, "/Equipment/HV/Variables/Demand", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "lemvac_check_sample_hv", "lemvac_check_sample_hv: lemvac_scfe: **ERROR** couldn't get FUG key from the ODB to check the sample HV.");
    return 1; // like HV on since I do not know
  }

  // check if any sample chamber HV demand value is not equal to zero
  size = sizeof(float);
  fval = -1.0;
  for (i=FUG_SC_RAL_IDX; i<=FUG_SC_SAMPLE_IDX; i++) {
    db_get_data_index(hDB, hKey, &fval, &size, i, TID_FLOAT);
    if (fval != 0.0) {
      state = 1;
      break;
    }
  }

  return state;
}

//--------------------------------------------------------------------
INT lemvac_check_sample_temp()
{
  INT state = 0;
  INT status;
  HNDLE hDB, hKey;
  INT size;
  float fval;

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

  // get SampleCryo frontend key
  status = db_find_key(hDB, 0, "/Equipment/SampleCryo/Variables/Input", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "lemvac_check_sample_temp", "lemvac_check_sample_temp: lemvac_scfe: **ERROR** couldn't get SampleCryo key from the ODB to check the sample CF1 temp.");
    return 1; // like T<90K since I do not know
  }

  size = sizeof(float);
  fval = 0.0;
  db_get_data_index(hDB, hKey, &fval, &size, SAMPLE_IN_CF1_IDX, TID_FLOAT);
  if (fval < 90.0)
    state = 1;

  return state;
}

//----------------------------------------------------------------------------
void lemvac_shutdown_sc_hv(LEMVAC_INFO *info)
{
  HNDLE hKey;
  INT size, i;
  float fval;

  // get the handle
  db_find_key(info->hDB, 0, "/Equipment/HV/Variables/Demand", &hKey);

  cm_msg(MINFO, "lemvac_shutdown_sc_hv", "lemvac_shutdown_sc_hv: shut down sample chamber HVs.");

  // shutdown the SC HVs
  size = sizeof(float);
  fval = 0.0;
  for (i=FUG_SC_RAL_IDX; i<=FUG_SC_SAMPLE_IDX; i++) {
    db_set_data_index(info->hDB, hKey, &fval, size, i, TID_FLOAT);
  }
}

//----------------------------------------------------------------------------
void lemvac_forced_warmup(LEMVAC_INFO *info)
{
  HNDLE hKey;
  INT size;
  float fval;

  // get the handle to the SampleCryo Output variable
  db_find_key(info->hDB, 0, "/Equipment/SampleCryo/Variables/Output", &hKey);

  cm_msg(MINFO, "lemvac_forced_warmup", "lemvac_forced_warmup: initiate forced warmup of the sample cryo.");

  // set LakeShore 340 ramping to zero
  size = sizeof(float);
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, SAMPLE_OUT_LS_RAMP, TID_FLOAT);
  ss_sleep(2000); // wait 2 sec before proceeding

  // set the set-point to 300K
  size = sizeof(float);
  fval = 300.0;
  db_set_data_index(info->hDB, hKey, &fval, size, SAMPLE_OUT_SET_POINT_IDX, TID_FLOAT);

  // set BH1, BH2 flow to 0
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, SAMPLE_OUT_BH1_FLOW_IDX, TID_FLOAT);
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, SAMPLE_OUT_BH2_FLOW_IDX, TID_FLOAT);
}

//----------------------------------------------------------------------------
void lemvac_check_pending_cmd(LEMVAC_INFO *info)
{
  ss_sleep(200); //as currently needed since SPS is too slow
  cm_yield(0); //as

  if (lemvac_pending_sc_cmd == LEMVAC_SC_PENDING_CMD_STOP) {
    if ((lemvac_sc_vent_state == 7) ||
        (lemvac_sc_vent_state == 15)) { // i.e. SC HVs down, T>=90K, and BPVY closed
      lemvac_stop_sc_pump(info);
      lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_IDLE;
    }
  } else if (lemvac_pending_sc_cmd == LEMVAC_SC_PENDING_CMD_VENT) {
    if (lemvac_sc_vent_state == 15) { // i.e. SC HVs down, T>=90K, BPVY closed, and SC pump off
      lemvac_vent_sc(info, VENT_CMD_START);
      lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_IDLE;
    } else if (lemvac_sc_vent_state == 7) { // i.e. i.e. SC HVs down, T>=90K, BPVY closed, but SC pump still on
      lemvac_stop_sc_pump(info);
    }
  }
}

//----------------------------------------------------------------------------
short spsToNumber(unsigned char *buffer)
{
  int val = 0;

  if (buffer[0] & 0x80)
    val = (buffer[0] &0x7f) << 8;
  else
    val = buffer[0] << 8;

  if (buffer[1] & 0x80) // sign bit set
    val += (buffer[1] &0x7f) + 128;
  else
    val += buffer[1];

  return val;
}

//----------------------------------------------------------------------------
int spsToWord(unsigned char *buffer)
{
  short val = buffer[0];
  val = val << 8;
  val += buffer[1];
  return val;
}

//----------------------------------------------------------------------------
double penning_ikr070(int analog)
{
  return exp(log(10.f)*(-11.f+0.8571*analog/100.f));
}

//----------------------------------------------------------------------------
double pirani_tpr018(int analog)
{
  double volt[30] = {0.0, 0.1, 0.201, 0.4523, 0.7035, 0.9146, 1.1055,
                     2.0653, 2.5377, 2.9045, 3.2111, 3.4623, 4.1106,
                     4.6583, 5.0251, 5.3618, 5.5879, 6.1457, 6.6181,
                     7.0553, 7.3970, 7.6935, 8.6683, 9.2462, 9.4975,
                     9.6080, 9.7085, 9.8543, 9.9497, 10.0};

  double p[30] = {1.0e-4, 1.0e-3, 0.002, 0.004, 0.006, 0.008, 0.01,
                  0.02, 0.04, 0.06, 0.08, 0.1, 0.2, 0.4, 0.6, 0.8,
                  1.0, 2.0, 4.0, 6.0, 8.0, 10.0, 20.0, 40.0, 60.0,
                  80.0, 100.0, 200.0, 400.0, 1000.0};

  if (analog > 32512) { // underrange
    return 1.0e-6;
  }

  double u = analog/100.f;
  double pressure;
  int i;

  // find closest voltage
  for (i=0; i<30; i++) {
    if (volt[i] > u)
      break;
  }

  if (i==0)
    pressure = 1.0e-4;
  else
    pressure = p[i-1]+(p[i]-p[i-1])*(u-volt[i-1])/(volt[i]-volt[i-1]);

  return pressure;
}

//----------------------------------------------------------------------------
BOOL lemvac_decode_data(LEMVAC_INFO *info, const char *buffer)
{  
  if ((buffer[4] != 65) || (buffer[5] != 66)) // check if buffer has the right 'AB' signature
    return FALSE;

  info->lemvac_data[LV_LIFESIGN] = spsToNumber((unsigned char*)&buffer[10]); // lifesign counter
  info->lemvac_data[LV_MCGR] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[368])); // MC_GR Pirani
  info->lemvac_data[LV_MCGT] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[370])); // MC_GT Pirani
  info->lemvac_data[LV_MCGJ] = penning_ikr070(spsToNumber((unsigned char*)&buffer[372])); // MC_GJ Penning
  info->lemvac_data[LV_MCGJ2] = penning_ikr070(spsToNumber((unsigned char*)&buffer[374])); // MC_GJ2 Penning
  info->lemvac_data[LV_TCGR] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[388])); // TC_GR Pirani
  info->lemvac_data[LV_TCGT] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[390])); // TC_GT Pirani
  info->lemvac_data[LV_TCGJ] = penning_ikr070(spsToNumber((unsigned char*)&buffer[392])); // TC_GJ Penning
  info->lemvac_data[LV_TCGJ2] = penning_ikr070(spsToNumber((unsigned char*)&buffer[394])); // TC_GJ2 Penning
  info->lemvac_data[LV_SCGR] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[408])); // SC_GR Pirani
  info->lemvac_data[LV_SCGT] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[410])); // SC_GT Pirani
  info->lemvac_data[LV_SCGJ] = penning_ikr070(spsToNumber((unsigned char*)&buffer[412])); // SC_GJ Penning
  info->lemvac_data[LV_SCGJ2] = penning_ikr070(spsToNumber((unsigned char*)&buffer[414])); // SC_GJ2 Penning
  info->lemvac_data[LV_PZGR] = pirani_tpr018(spsToNumber((unsigned char*)&buffer[508])); // PZ_GR Pirani
  info->lemvac_data[LV_MCSTAT1] = spsToWord((unsigned char*)&buffer[360]); // MC Status Word 1
  info->lemvac_data[LV_MCSTAT2] = spsToWord((unsigned char*)&buffer[362]); // MC Status Word 2
  info->lemvac_data[LV_MCSTAT3] = spsToWord((unsigned char*)&buffer[364]); // MC Status Word 3
  info->lemvac_data[LV_TCSTAT1] = spsToWord((unsigned char*)&buffer[380]); // TC Status Word 1
  info->lemvac_data[LV_TCSTAT2] = spsToWord((unsigned char*)&buffer[382]); // TC Status Word 2
  info->lemvac_data[LV_TCSTAT3] = spsToWord((unsigned char*)&buffer[384]); // TC Status Word 3
  info->lemvac_data[LV_SCSTAT1] = spsToWord((unsigned char*)&buffer[400]); // SC Status Word 1
  info->lemvac_data[LV_SCSTAT2] = spsToWord((unsigned char*)&buffer[402]); // SC Status Word 2
  info->lemvac_data[LV_SCSTAT3] = spsToWord((unsigned char*)&buffer[404]); // SC Status Word 3
  info->lemvac_data[LV_PZSTAT1] = spsToWord((unsigned char*)&buffer[500]); // PZ Status Word 1
  info->lemvac_data[LV_PZSTAT2] = spsToWord((unsigned char*)&buffer[502]); // PZ Status Word 2
  info->lemvac_data[LV_BPVX] = spsToWord((unsigned char*)&buffer[600]); // BPVX Status Word
  info->lemvac_data[LV_BPVY] = spsToWord((unsigned char*)&buffer[610]); // BPVY Status Word

  return TRUE;
}

//----------------------------------------------------------------------------
void lemvac_deal_with_handshake(LEMVAC_INFO *info)
{
  int status, cmd, cmd_tag;
  // the handshake string has the following structure d0;d1
  // where d0 is the command : 1 = BPVX toggle, 3 = BPVY toggle, 5 = SC pump, 7 = SC vent
  // and d1 ist the command tag: 1,2,3 for BPVX/Y; 0 (stop), or 1 (start) for SC pump/vent

  // tokenize handshake command
  status = sscanf(info->handshake_cmd, "%d;%d", &cmd, &cmd_tag);
  if (status != 2) {
    cm_msg(MINFO, "lemvac_deal_with_handshake", "lemvac_deal_with_handshake: **ERROR** when tokenize handshake command ('%s').", info->handshake_cmd);
    return;
  }

  // check cmd
  switch (cmd) {
    case 1: // BPVX
      if (cmd_tag != 0) {
        if (((int)info->lemvac_data[LV_BPVX] & LV_BIT3) ||
            ((int)info->lemvac_data[LV_BPVX] & LV_BIT4)) { // BPVX open or closed present -> cmd OK hence reset
          info->handshake_err_count[0] = 0;
          info->lemvac_buffer[604] = (char)0;
          lemvac_write_cmd(info);
        } else {
          info->handshake_err_count[0]++;
          if ((info->handshake_err_count[0] + 5) % 10 == 0)
            cm_msg(MINFO, "lemvac_deal_with_handshake", "lemvac_deal_with_handshake: **WARNING** toggle BPVX failed.");
          return;
        }
      }
      break;
    case 3: // BPVY
      if (cmd_tag != 0) {
        if (((int)info->lemvac_data[LV_BPVY] & LV_BIT3) ||
            ((int)info->lemvac_data[LV_BPVY] & LV_BIT4)) { // BPVY open or closed present -> cmd OK hence reset
          info->handshake_err_count[1] = 0;
          info->lemvac_buffer[614] = (char)0;
          lemvac_write_cmd(info);
        } else {
          info->handshake_err_count[1]++;
          if ((info->handshake_err_count[1] + 5) % 10 == 0)
            cm_msg(MINFO, "lemvac_deal_with_handshake", "lemvac_deal_with_handshake: **WARNING** toggle BPVY failed.");
          return;
        }
      }
      break;
    case 5: // SC pump start/stop cmd
      if ((cmd_tag == 1) &&
          (((int)info->lemvac_data[LV_SCSTAT1] & LV_BIT0) ||
           ((int)info->lemvac_data[LV_SCSTAT1] & LV_BIT2) ||
           ((int)info->lemvac_data[LV_SCSTAT1] & LV_BIT3))) { // start pump
        info->handshake_err_count[2] = 0;
        info->lemvac_buffer[416] = (char)0;
        lemvac_write_cmd(info);
      } else if ((cmd_tag == 0) && ((int)info->lemvac_data[LV_SCSTAT1] & LV_BIT1)) { // stop pump
        info->handshake_err_count[2] = 0;
        info->lemvac_buffer[416] = (char)0;
        lemvac_write_cmd(info);
      } else {
        info->handshake_err_count[2]++;
        if ((info->handshake_err_count[2] + 5) % 10 == 0)
          cm_msg(MINFO, "lemvac_deal_with_handshake", "lemvac_deal_with_handshake: **WARNING** pump cmd failed.");
        return;
      }
      break;
    case 7: // SC vent start/stop cmd
      if ((cmd_tag == 1) && ((int)info->lemvac_buffer[416] != 0)) { // vent on
        info->handshake_err_count[3] = 0;
        info->lemvac_buffer[416] = (char)0;
        lemvac_write_cmd(info);
      } else if ((cmd_tag == 0) && (int)info->lemvac_data[LV_SCSTAT1] & LV_BIT9) { // vent off
        info->handshake_err_count[3] = 0;
        info->lemvac_buffer[416] = (char)0;
        lemvac_write_cmd(info);
      } else {
        info->handshake_err_count[3]++;
        if ((info->handshake_err_count[3] + 5) % 10 == 0)
          cm_msg(MINFO, "lemvac_deal_with_handshake", "lemvac_deal_with_handshake: **WARNING** pump/vent cmd failed.");
        return;
      }
      break;
    default:
      cm_msg(MINFO, "lemvac_deal_with_handshake", "lemvac_deal_with_handshake: **ERROR** you never should have reached this point.");
      return;
      break;
  }

  // reset handshake_cmd
  strncpy(info->handshake_cmd, "", sizeof(info->handshake_cmd));
}

//----------------------------------------------------------------------------
void lemvac_get_all(LEMVAC_INFO *info)
{
  INT  status;
  char data[SPS_MAX_BYTES];

  float delta = ss_time()-info->time;
  // check timer, if smaller then time constant do nothing
  if (delta < LEMVAC_TIME_CONST)
    return;

  // communication error report handling
  delta = ss_time()-info->errTime;
  if (delta > LEMVAC_TIMEOUT_ERROR) {
    if ((info->tcpip_open_error != 0) || (info->read_error != 0)) {
      if (info->intern.detailed_msg) {
        cm_msg(MINFO, "lemvac_get_all",
               "lemvac_get_all: No of tcpip open errors = %d, tcpip read errors =%d of %d readings in the last %d secs.",
               info->tcpip_open_error, info->read_error, info->read_counts, LEMVAC_TIMEOUT_ERROR);
        cm_yield(0);
      }
      // reset error counters
      info->tcpip_open_error = 0;
      info->read_error = 0;
      info->read_counts = 0;
      // restart timer
      info->errTime = ss_time();
    }
  }

  // get data
  status = info->bd(CMD_READ, info->bd_info, &data[0], sizeof(data), 3000); // read data
  if (info->intern.detailed_msg) {
    cm_msg(MDEBUG, "lemvac_get_all", "lemvac_get_all: get data (status=%d)", status);
    cm_yield(0);
  }
  if (status == SPS_MAX_BYTES) {
    memcpy(info->lemvac_buffer, data, SPS_MAX_BYTES);
  } else {
    if (info->intern.detailed_msg) {
      cm_msg(MINFO, "lemvac_get_all", "lemvac_get_all: get.data.status=%d", status);
      cm_yield(0);
    }
    info->read_counts++;
  }

  // check for errors
  // (error byte set) or (haven't gotten all the data)
  if (status != SPS_MAX_BYTES) {
    info->read_error++;
    return;
  } else {
    info->read_counts = 0;
    if (!lemvac_decode_data(info, data)) {
      info->read_error++;
    } else { // only check potential handshake if decoding is ok
      // check if handshake command is pending
      if (strlen(info->handshake_cmd) > 0) {
        lemvac_deal_with_handshake(info);
      }
    }
  }

  info->time = ss_time(); // restart timer

  // update lemvac_sc_vent_state: check BPVY
  if (info->lemvac_data[LV_BPVY] == 3072.f) // BPVY closed
    lemvac_sc_vent_state |= 1 << VENT_STATE_BPVY_BIT; // set BPVY state bit, i.e. BPVY closed
  else
    lemvac_sc_vent_state &= ~(1 << VENT_STATE_BPVY_BIT); // clear BPVY state bit, i.e. BPVY is open

  // update lemvac_sc_vent_state: check SC pump state
  if (info->lemvac_data[LV_SCSTAT1] == 18827) // SC pump state: pumping
    lemvac_sc_vent_state &= ~(1 << VENT_STATE_PUMP_BIT); // clear pump state bit, i.e. sample chamber is pumping
  else
    lemvac_sc_vent_state |= 1 << VENT_STATE_PUMP_BIT; // set pump state bit, i.e. sample chamber pumping is stopped

  // update lemvac_sc_vent_state: check sample HV's
  if (lemvac_check_sample_hv() == 1) // HV on
    lemvac_sc_vent_state &= ~(1 << VENT_STATE_HV_BIT); // clear HV bit, i.e. HV on
  else // HV off
    lemvac_sc_vent_state |= 1 << VENT_STATE_HV_BIT; // set HV bit

  // update lemvac_sc_vent_state: check sample temperature T<90 or T>=90
  if (lemvac_check_sample_temp() == 1) // CF1 temp < 90K
    lemvac_sc_vent_state &= ~(1 << VENT_STATE_TEMP_BIT); // clear sample temperature bit, i.e. T<90K
  else // CF1 temp >= 90K
    lemvac_sc_vent_state |= 1 << VENT_STATE_TEMP_BIT; // set sample temperature bit

  // check for pending commands
  lemvac_check_pending_cmd(info);

  // ------------------------------------------------------------------------------------
  // check the HV interlock setting for the various chambers.
  // The HV interlock fires if the pressure > 1e-6, i.e. if the corresponding pressure
  // decade bit is NOT set (see DB50, e.g. byte 352).
  // If a gas inlet action is going on, no alarm is given, since it is assumed that the
  // user knows what he is doing!

  // check if MC HV interlock fired and there was not a gas inlet action
  if (!(info->lemvac_buffer[361] & LV_HV_NO_INTERLOCK_FLAG) &&
      !(info->lemvac_buffer[363] & LV_GAS_INLET_FLAG)) {
    al_trigger_alarm( "lemvac_get_all", "MC High Voltage Interlock Activated", "Alarm",
                      "Manual Reset Needed", AT_INTERNAL);
    lemvac_set_sliding_valve(info, LV_BPVX_CMD, LV_BPV_CMD_CLOSE); // close BPVX
  }

  // check if TC HV interlock fired and there was not a gas inlet action
  if (!(info->lemvac_buffer[381] & LV_HV_NO_INTERLOCK_FLAG) &&
      !(info->lemvac_buffer[383] & LV_GAS_INLET_FLAG)) {
    al_trigger_alarm( "lemvac_get_all", "TC High Voltage Interlock Activated", "Alarm",
                      "Manual Reset Needed", AT_INTERNAL);
    lemvac_set_sliding_valve(info, LV_BPVX_CMD, LV_BPV_CMD_CLOSE); // close BPVX
    lemvac_set_sliding_valve(info, LV_BPVY_CMD, LV_BPV_CMD_CLOSE); // close BPVY
  }

  // check if SC HV interlock fired and there was not a gas inlet action
  if (!(info->lemvac_buffer[401] & LV_HV_NO_INTERLOCK_FLAG) &&
      !(info->lemvac_buffer[403] & LV_GAS_INLET_FLAG)) {
    al_trigger_alarm( "lemvac_get_all", "SC High Voltage Interlock Activated", "Alarm",
                      "Manual Reset Needed", AT_INTERNAL);
    lemvac_set_sliding_valve(info, LV_BPVY_CMD, LV_BPV_CMD_CLOSE); // close BPVY
  }

  // end HV interlock checks
  // ------------------------------------------------------------------------------------
}

//----------------------------------------------------------------------------
void lemvac_write_cmd(LEMVAC_INFO *info)
{
  int status;

  info->tcpip_open_error = 0;

  // write stuff
  status = info->bd(CMD_WRITE, info->bd_info, &info->lemvac_buffer[0], sizeof(info->lemvac_buffer)); // write data
  if (info->intern.detailed_msg) {
    cm_msg(MDEBUG, "lemvac_write_cmd", "lemvac_write_cmd: write data (status=%d)", status);
    cm_yield(0);
  }
}

//----------------------------------------------------------------------------
void lemvac_set_sliding_valve(LEMVAC_INFO *info, INT valve, float value)
{
  BOOL open;
  int status, size, odb_idx;
  int bpv_state, idx;
  float fval;
  HNDLE hKey;
  char cmd[32];

  if (value == 0.0)
    return;

  // get the handle to the output variables
  status = db_find_key(info->hDB, 0, "/Equipment/LEMVAC/Variables/Output", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MINFO, "lemvac_set_sliding_valve", "lemvac_set_sliding_valve: couldn't get the output variable key.");
    return;
  }

  // get the BPV state (open or closed) and reset the toggle command
  if (valve == 1) { // BPVX
    idx = 600; // lemvac_buffer index
  } else if (valve == 3) { // BPVY
    idx = 610; // lemvac_buffer index
  }
  bpv_state = spsToWord((unsigned char*)&info->lemvac_buffer[idx]);

  // check the current BPVX/Y state
  if ((bpv_state & LV_BIT4) && (bpv_state & LV_BIT2) && !(bpv_state & LV_BIT3)) {
    open = TRUE;
  } else {
    open = FALSE;
  }

  // set command back to idle
  size = sizeof(float);
  fval = 0.0;
  if (idx == 600)
    odb_idx = 1; // ODB index
  else
    odb_idx = 3; // ODB index
  status = db_set_data_index(info->hDB, hKey, &fval, size, odb_idx, TID_FLOAT);

  // check if the current state and the given command correspond in which case nothing has to be done
  if ((open == TRUE) && (value == 2.0)) // current state 'open', command 'open', hence nothing to be done
    return;
  if ((open == FALSE) && (value == 3.0)) // current state 'closed', command 'closed', hence nothing to be done
    return;

  // write the command to the SPS
  if (open == TRUE) { // currently open, hence close
    info->lemvac_buffer[idx+4] = (char)2;
  } else { // currently closed, hence open
    info->lemvac_buffer[idx+4] = (char)1;
  }
  lemvac_write_cmd(info);

  // set handshake command string
  sprintf(cmd, "%d;%d", valve, (int)value);
  strncpy(info->handshake_cmd, cmd, sizeof(info->handshake_cmd));
}

//----------------------------------------------------------------------------
void lemvac_start_sc_pump(LEMVAC_INFO *info)
{
  HNDLE hKey;
  INT size;
  float fval;
  char cmd[32];

  cm_msg(MDEBUG, "lemvac_start_sc_pump", "lemvac_start_sc_pump: will start SC pump.");
  cm_yield(0);

  if ((int)info->lemvac_data[LV_SCSTAT1] & LV_BIT0 ||
      (int)info->lemvac_data[LV_SCSTAT1] & LV_BIT2 ||
      (int)info->lemvac_data[LV_SCSTAT1] & LV_BIT3) {
    cm_msg(MDEBUG, "lemvac_start_sc_pump", "lemvac_start_sc_pump: SC pump already running. Will do nothing.");
    cm_yield(0);
  } else { // pump != running, hence send start command
    info->lemvac_buffer[416] = (char)1; // SC PS_On command
    lemvac_write_cmd(info);

    // set handshake command string
    sprintf(cmd, "%d;%d", 5, 1);
    strncpy(info->handshake_cmd, cmd, sizeof(info->handshake_cmd));
  }

  // reset cmd tag, i.e. set it to idle
  db_find_key(info->hDB, 0, "/Equipment/LEMVAC/Variables/Output", &hKey);
  size = sizeof(float);
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, LV_SC_PUMP_CMD, TID_FLOAT);

  // disable SC pump cmd enabled
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, LV_SC_PUMP_CMD_ENABLED, TID_FLOAT);
}

//----------------------------------------------------------------------------
void lemvac_stop_sc_pump(LEMVAC_INFO *info)
{
  HNDLE hKey;
  INT size;
  float fval;
  char cmd[32];

  cm_msg(MDEBUG, "lemvac_stop_sc_pump", "lemvac_stop_sc_pump: will stop SC pump.");
  cm_yield(0);

  // get current SC pump state
  if ((int)info->lemvac_data[LV_SCSTAT1] & LV_BIT1) {
    cm_msg(MDEBUG, "lemvac_stop_sc_pump", "lemvac_stop_sc_pump: SC pump already stopped. Will do nothing.");
    cm_yield(0);
  } else { // pump != stopped, hence send stop command
    info->lemvac_buffer[416] = (char)2; // SC PS_Off command
    lemvac_write_cmd(info);

    // set handshake command string
    sprintf(cmd, "%d;%d", 5, 0);
    strncpy(info->handshake_cmd, cmd, sizeof(info->handshake_cmd));
  }


  // reset cmd tag, i.e. set it to idle
  db_find_key(info->hDB, 0, "/Equipment/LEMVAC/Variables/Output", &hKey);
  size = sizeof(float);
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, LV_SC_PUMP_CMD, TID_FLOAT);

  // disable SC pump cmd
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, LV_SC_PUMP_CMD_ENABLED, TID_FLOAT);
}

//----------------------------------------------------------------------------
void lemvac_prepare_stop_sc_pump(LEMVAC_INFO *info, BOOL forced)
{
  if (lemvac_sc_vent_state == 7) { // all necessary conditions fulfilled, i.e. HV SC down, T>=90K, and BPVY closed
    lemvac_stop_sc_pump(info);
    return;
  }

  if (!(lemvac_sc_vent_state & (1 << VENT_STATE_HV_BIT))) { // HV FUG SC still on
    lemvac_shutdown_sc_hv(info);
  }
  if (!(lemvac_sc_vent_state & (1 << VENT_STATE_BPVY_BIT))) { // BPVY still open
    lemvac_set_sliding_valve(info, LV_BPVY_CMD, LV_BPV_CMD_CLOSE);
  }
  if (!(lemvac_sc_vent_state & (1 << VENT_STATE_TEMP_BIT))) { // sample CF1 T<90K
    if (forced == TRUE) {
      lemvac_forced_warmup(info);
    } else {
      cm_msg(MINFO, "lemvac_prepare_stop_sc_pump", "lemvac_prepare_stop_sc_pump: CF1 T<90K, will stop the SC pump as soon as T>=90K. But you need to initiate it.");
      cm_yield(0);
    }
  }

  lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_STOP;
}

//----------------------------------------------------------------------------
void lemvac_prepare_venting_sc(LEMVAC_INFO *info, BOOL forced)
{
  if (lemvac_sc_vent_state == 15) { // all necessary conditions fulfilled, i.e. HV SC down, BPVY closed, T>=90K, SC turbo pump stopped
    lemvac_vent_sc(info, VENT_CMD_START);
    return;
  }

  if (!(lemvac_sc_vent_state & (1 << VENT_STATE_HV_BIT))) { // HV FUG still on
    lemvac_shutdown_sc_hv(info);
  }
  if (!(lemvac_sc_vent_state & (1 << VENT_STATE_BPVY_BIT))) { // BPVY still open
    lemvac_set_sliding_valve(info, LV_BPVY_CMD, LV_BPV_CMD_CLOSE);
  }
  if (!(lemvac_sc_vent_state & (1 << VENT_STATE_TEMP_BIT))) { // sample CF1 T<90K
    if (forced == TRUE) {
      lemvac_forced_warmup(info);
    } else {
      cm_msg(MINFO, "lemvac_prepare_venting_sc", "lemvac_prepare_venting_sc: CF1 T<90K, will start venting the SC as soon as T>=90K. But you need to initiate it.");
    }
  }

  lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_VENT;
}

//----------------------------------------------------------------------------
void lemvac_vent_sc(LEMVAC_INFO *info, INT cmd)
{
  HNDLE hKey;
  INT status, size;
  float fval;
  char cmdStr[32];

  // vent
  if (cmd == VENT_CMD_STOP) { // stop venting command requested
    info->lemvac_buffer[416] = (char)64; // vent off command
    lemvac_write_cmd(info);

    // set handshake command string
    sprintf(cmdStr, "%d;%d", 7, cmd);
    strncpy(info->handshake_cmd, cmdStr, sizeof(info->handshake_cmd));
  } else if (cmd == VENT_CMD_START) { // start venting command requested
    info->lemvac_buffer[416] = (char)32; // vent on command
    lemvac_write_cmd(info);

    // set handshake command string
    sprintf(cmdStr, "%d;%d", 7, cmd);
    strncpy(info->handshake_cmd, cmdStr, sizeof(info->handshake_cmd));
  } else {
    cm_msg(MDEBUG, "lemvac_vent_sc", "lemvac_vent_sc: **ERROR** recived unkown vent command.");
    cm_yield(0);
  }

  // update ODB vent state
  status = db_find_key(info->hDB, 0, "/Equipment/LEMVAC/Variables/Output", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "lemvac_vent_sc", "lemvac_vent_sc: **ERROR** couldn't get lemvac output variable key.");
    return;
  }

  // disable venting
  size = sizeof(float);
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, LV_SC_VENT_CMD, TID_FLOAT);
  fval = 0.0;
  db_set_data_index(info->hDB, hKey, &fval, size, LV_SC_VENT_CMD_ENABLED, TID_FLOAT);

  // status message
  if (cmd == VENT_CMD_START) {
    cm_msg(MINFO, "lemvac_vent_sc", "lemvac_vent_sc: sample chamber vented.");
  } else {
    cm_msg(MINFO, "lemvac_vent_sc", "lemvac_vent_sc: stop venting the sample chamber.");
  }
  cm_yield(0);
}

/*---- device driver routines ------------------------------------------------*/

/*----------------------------------------------------------------------------*/
INT lemvac_in_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  INT   status, size, i;
  char  str[512];
  HNDLE hDB, hkeydd;

  // allocate info structure
  gInfo = (LEMVAC_INFO *)calloc(1, sizeof(LEMVAC_INFO));
  *pinfo = gInfo;

  // get ODB handle
  cm_get_experiment_database(&hDB, NULL);
  // store handles (ODB and DD key) in local structure to keep it for latter use
  gInfo->hDB = hDB;
  gInfo->hKey_in = hKey;

  // create lemvac DD intern structure if not already exists
  status = db_find_key(hDB, hKey, "DD/intern", &hkeydd);
  if (status != DB_SUCCESS) { // key doesn't exist yet
    // create lemvac DD intern
    status = db_create_record(hDB, hKey, "DD/intern", LAMVAC_INTERN_STR);
    if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
      cm_msg(MERROR, "lemvac_init", "lemvac_init: Error creating lemvac intern record in ODB, status=%d", status);
      cm_yield(0);
      return FE_ERR_ODB;
    }
  }
  db_find_key(hDB, hKey, "DD/intern", &hkeydd);
  size = sizeof(gInfo->intern);
  status = db_get_record(hDB, hkeydd, &gInfo->intern, &size, 0);
  // open hotlink
  status = db_open_record(hDB, hkeydd, &gInfo->intern, size, MODE_READ, NULL, NULL);

  // create lemvac DD names record
  status = db_create_record(hDB, hKey, "DD/Names", LEMVAC_NAMES_STR);
  if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
    cm_msg(MERROR, "lemvac_init", "lemvac_init: Error creating lemvac Names record in ODB, status=%d", status);
    cm_yield(0);
    return FE_ERR_ODB;
  }
  db_find_key(hDB, hKey, "DD/Names", &hkeydd);
  size = sizeof(gInfo->lemvac_names);
  db_get_record(hDB, hkeydd, &gInfo->lemvac_names, &size, 0);


  // check if lemvac DD SPS-DB buffer record already exists
  status = db_find_key(hDB, hKey, "DD/DB_Buffer", &hkeydd);
  if (status != DB_SUCCESS) { // key doesn't exist yet
    // create lemvac DD DB buffer
    strcpy(str, "DB_Buffer = BYTE[680] : \n");
    for (i=0; i<SPS_MAX_BYTES; i++)
      strcat(str, " \n");
    status = db_create_record(hDB, hKey, "DD/DB_Buffer", str);
    if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
      cm_msg(MERROR, "lemvac_init", "lemvac_init: Error creating lemvac DB_Buffer record in ODB, status=%d", status);
      cm_yield(0);
      return FE_ERR_ODB;
    }
  }

  db_find_key(hDB, hKey, "DD/DB_Buffer", &hkeydd);
  size = sizeof(gInfo->lemvac_buffer);
  status = db_get_record(hDB, hkeydd, &gInfo->lemvac_buffer, &size, 0);
  // open hotlink
  status = db_open_record(hDB, hkeydd, &gInfo->lemvac_buffer, size, MODE_WRITE, NULL, NULL);
  gInfo->hKey_DB_Buffer = hkeydd;

  // initialize driver
  gInfo->bd = bd;                 // keep the bus driver entry function
  gInfo->bd_info = 0;             // initialize the pointer to the BD info structure
  gInfo->bpv_enabled[0] = 0;      // initialize BPVX enable flag
  gInfo->bpv_enabled[1] = 0;      // initialize BPVY enable flag
  gInfo->sc_pump_cmd_enabled = 0; // initialize SC pump cmd enable flag
  gInfo->sc_vent_cmd_enabled = 0; // initialize SC vent cmd enable flag
  strncpy(gInfo->handshake_cmd, "", sizeof(gInfo->handshake_cmd)); // initialize handshake cmd
  for (i=0; i<4; i++)
    gInfo->handshake_err_count[i] = 0;
  gInfo->time = ss_time();        // timer for error handling
  gInfo->errTime = ss_time();     // timer for error handling
  gInfo->read_error = 0;          // read error counter
  gInfo->tcpip_open_error = 0;    // open tcpip error counter
  gInfo->read_counts = 0;         // counter how often tcpip reading has benn attempt
  gInfo->last_success = 0;

  // initialize vent state variable
  lemvac_sc_vent_state = 0;

  // initialize pending command variable
  lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_IDLE;

  // open tcpip connection
  status = gInfo->bd(CMD_INIT, gInfo->hKey_in, &gInfo->bd_info);
  if (gInfo->intern.detailed_msg) {
    cm_msg(MDEBUG, "lemvac_init", "lemvac_init: open tcpip connection (status=%d)", status);
    cm_yield(0);
  }
  if (status != SUCCESS) {
    gInfo->tcpip_open_error++;
    if (gInfo->intern.detailed_msg) {
      cm_msg(MINFO, "lemvac_init", "lemvac_init: open bounced off");
      cm_yield(0);
    }
    return FE_ERR_DRIVER;
  }

  // initialize lemvac status message
  cm_msg(MINFO, "lemvac_init", "lemvac initialized ...");
  cm_yield(0);

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemvac_out_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  *pinfo = gInfo; // since gInfo has been allocated in lemvac_in_init, it is enough to pass the pointer

  // initialize driver
  gInfo->hKey_out = hKey;    // keep the DD entry key

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemvac_exit(LEMVAC_INFO *info)
{
  // close all hotlinks
  db_close_record(info->hDB, info->hKey_DB_Buffer);

  // close connection
  info->bd(CMD_EXIT, info->bd_info);

  free(info);
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT lemvac_set(LEMVAC_INFO *info, INT channel, float value)
{
  switch (channel) {
    case LV_BPVX_ENABLED: // enable/disable flag BPVX
      info->bpv_enabled[0] = (int)value;
      break;
    case LV_BPVY_ENABLED: // enable/disable flag BPVY
      info->bpv_enabled[1] = (int)value;
      break;
    case LV_BPVX_CMD: // BPVX open/close command
      if (info->bpv_enabled[0]) {
        lemvac_set_sliding_valve(info, channel, value);
      }
      break;
    case LV_BPVY_CMD: // BPVY open/close command
      if (info->bpv_enabled[1]) {
        lemvac_set_sliding_valve(info, channel, value);
      }
      break;
    case LV_SC_PUMP_CMD_ENABLED:
      info->sc_pump_cmd_enabled = (int)value;
      break;
    case LV_SC_PUMP_CMD:
      if (!info->sc_pump_cmd_enabled && (value > 0.0)) {
        cm_msg(MERROR, "lemvac_set", "lemvac_set: **WARNING** pump cmd not enabled! Will do nothing!");
        return FE_SUCCESS;
      }
      if (value == 0.0) {
        lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_IDLE;
      } else if (value == 1.0) {
        lemvac_vent_sc(info, VENT_CMD_STOP); // make sure venting is stopped
        ss_sleep(200); //as currently needed since the SPS is too slow
        cm_yield(0); //as
        lemvac_start_sc_pump(info);
      } else if (value == 2.0) {
        lemvac_prepare_stop_sc_pump(info, FALSE); // stop pump if T>90K, do nothing on the SC temperature controller
      } else if (value == 3.0) {
        lemvac_prepare_stop_sc_pump(info, TRUE);  // stop pump if T>90K, if T<90K initiate warmup
      } else {
        cm_msg(MERROR, "lemvac_set", "lemvac_set: **ERROR** found unsupported SC pump cmd %d. Will do nothing.", (int)value);
        cm_yield(0);
      }
      break;
    case LV_SC_VENT_CMD_ENABLED:
      info->sc_vent_cmd_enabled = (int)value;
      break;
    case LV_SC_VENT_CMD:
      if (!info->sc_vent_cmd_enabled && (value > 0.0)) {
        cm_msg(MERROR, "lemvac_set", "lemvac_set: **WARNING** vent cmd not enabled! Will do nothing!");
        return FE_SUCCESS;
      }
      if (value == 0.0) {
        lemvac_pending_sc_cmd = LEMVAC_SC_PENDING_CMD_IDLE;
      } else if (value == 1.0) {
        lemvac_vent_sc(info, VENT_CMD_STOP);
      } else if (value == 2.0) {
        lemvac_prepare_venting_sc(info, FALSE); // vent as soon as T>90K, but do nothing on the SC temperature controller, BH flow, etc.
      } else if (value == 3.0) {
        lemvac_prepare_venting_sc(info, TRUE);  // vent as soon as T>90K, if T<90K initiate warmup
      } else {
        cm_msg(MERROR, "lemvac_set", "lemvac_set: **ERROR** found unsupported SC vent cmd %d. Will do nothing.", (int)value);
        cm_yield(0);
      }
      break;
    default:
      break;
  }

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT lemvac_in_get_label(LEMVAC_INFO *info, INT channel, char *name)
{
  strcpy(name, info->lemvac_names.in_name[channel]);
  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT lemvac_out_get_label(LEMVAC_INFO *info, INT channel, char *name)
{
  strcpy(name, info->lemvac_names.out_name[channel]);
  return FE_SUCCESS;
}

//-----------------------------------------------------------------------------
INT lemvac_get(LEMVAC_INFO *info, INT channel, float *pvalue)
{
  if (info->intern.detailed_msg > 1) {
    cm_msg(MDEBUG, "lemvac_get", "in lemvac_get ...");
    cm_yield(0);
  }

  if (channel % (LEMVAC_IN_VARS / 2) == 0) { // only read if channel is 0 or (LEMVAC_IN_VARS / 2) since all data are read at once
    if (info->intern.detailed_msg) {
      cm_msg(MDEBUG, "lemvac_get", "in lemvac_get and will call lemvac_get_all(info)");
      cm_yield(0);
    }
    lemvac_get_all(info);
  }

  *pvalue = info->lemvac_data[channel];

  ss_sleep(10);
  return FE_SUCCESS;
}

//---- device driver entry point -----------------------------------
INT lemvac_in(INT cmd, ...)
{
va_list argptr;
HNDLE   hKey;
INT     channel, status;
float   *pvalue;
void    *info, *bd;
char    *name;
DWORD   flags;

  va_start(argptr, cmd);
  status = FE_SUCCESS;

  switch (cmd) {
    case CMD_INIT:
      hKey = va_arg(argptr, HNDLE);
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      flags = va_arg(argptr, DWORD);
      bd = va_arg(argptr, void *);
      status = lemvac_in_init(hKey, info, channel, bd);
      break;

    case CMD_EXIT:
      info = va_arg(argptr, void *);
      status = lemvac_exit(info);
      break;

    case CMD_GET:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue  = va_arg(argptr, float*);
      status = lemvac_get(info, channel, pvalue);
      break;

    case CMD_GET_LABEL:
      info    = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      name    = va_arg(argptr, char *);
      status  = lemvac_in_get_label(info, channel, name);
      break;

    default:
      break;
    }

  va_end(argptr);

  return status;
}

//---- device driver entry point -----------------------------------
INT lemvac_out(INT cmd, ...)
{
va_list argptr;
HNDLE   hKey;
INT     channel, status;
float   value;
void    *info, *bd;
char    *name;
DWORD   flags;

  va_start(argptr, cmd);
  status = FE_SUCCESS;

  switch (cmd) {
    case CMD_INIT:
      hKey = va_arg(argptr, HNDLE);
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      flags = va_arg(argptr, DWORD);
      bd = va_arg(argptr, void *);
      status = lemvac_out_init(hKey, info, channel, bd);
      break;

    case CMD_GET_LABEL:
      info    = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      name    = va_arg(argptr, char *);
      status  = lemvac_out_get_label(info, channel, name);
      break;

    case CMD_SET:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      value   = (float) va_arg(argptr, double);      
      status = lemvac_set(info, channel, value);
      break;

    default:
      break;
    }

  va_end(argptr);

  return status;
}
//---- end --------------------------------------------------------------