steppermotor.c

Go to the documentation of this file.

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

  Name:         steppermotor.c
  Created by:   Ge Nieuwenhuys   2006/10/12

  Contents: device driver for the steppermotor
            defined as a multi class device.

   RS232: 9600 baud, 8 data bits, 1 stop bit, no parity bit,
          protocol: no flow control, termination \r\n (CR\LF)

   July, 20, 2007: changed readback device for tent from LS340 to K2700

********************************************************************/

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

#include "midas.h"
#include "steppermotor.h"

#include "ets_logout.h"
#include "lemSCWatchdog.h"

/*---- globals -----------------------------------------------------*/

#define SM_ETS_LOGOUT_SLEEP 10000

#define SM_TIME_OUT            2000    
#define SM_TIME_BETWEEN_SETS     10    
#define SM_ACCURACY               1.0  

/* --------- to handle error messages ------------------------------*/

#define SM_RECONNECTION_TIMEOUT 5
#define SM_MAX_READBACK_FAILURE 5
#define SM_MAX_RECONNECTION_FAILURE 5


#define SM_MAX_ERROR 3             
#define SM_DELTA_TIME_ERROR 3600   
#define SM_MAX_TRY  10             
#define SM_WAIT 500                
#define SM_INIT_ERROR -2           
#define SM_READ_ERROR -1           

#define SM_DEBUG 0

#define SM_K2700_CH        20
#define SM_K2700_SIG_CH    4
#define SM_K2700_POT_CH    2
#define SM_SCS900_CH       32
#define SM_SCS900_SIG_CH   4
#define SM_SCS900_POT_CH   2
#define SM_SCS2001M_CH     44
#define SM_SCS2001M_SIG_CH 14
#define SM_SCS2001M_POT_CH 15

typedef struct {
  INT   odb_offset;        
  INT   detailed_msg;      
  INT   ets_in_use;        
  INT   scw_in_use;        
  INT   no_connection;     
  INT   reconnect_timeout; 
  INT   read_timeout;      
} SM_INTERNAL;

#define SM_INTERNAL_STR "\
ODB Offset = INT : 12\n\
Detailed Messages = INT : 0\n\
ETS_IN_USE = INT : 1\n\
SCW_IN_USE = INT : 0\n\
No Connection = INT : 1\n\
Reconnection Timeout = INT : 10\n\
Read Timeout = INT : 5\n"

typedef struct {
  float pcurve[3];            
  float valve_range;          
  float mhc;                  
  float mac_open;             
  float mac_close;            
  float mrc_open;             
  float mrc_close;            
  float signature;            
  } SM_INDIVIDUAL;

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

typedef struct {
  char read_back_device[NAME_LENGTH]; 
  SM_INTERNAL intern;         
  INT         FromAutoPress;  
  INT         ToAutoPress;    
  float       Tau_PID[4];     
  SM_INDIVIDUAL individual[5];
} SM_SETTINGS;

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

typedef struct {
  SM_SETTINGS sm_settings;         
  LEM_SC_WATCHDOG scw;             
  HNDLE hDB;                       
  HNDLE hkey;                      
  HNDLE hkey_no_connection;        
  char  sm_in_name[NAME_LENGTH];
  char  sm_out_name[NAME_LENGTH];
  char  sm_modus_name[NAME_LENGTH];
  INT (*bd)(INT cmd, ...);         
  void *bd_info;                   
  INT   startup_error;             
  int   sm_in_use;                 
  int   modus;                     
  int   bd_connected;              
  int   first_bd_error;            
  DWORD last_reconnect;            
  INT   reconnection_failures;     
  DWORD last_set_time;             
  float signature;                 
  float setpoint;                  
  float position;                  
  float velocity;                  
  float voltage;                   
  float *data;                     
  int   FromAutoPress;             
} SM_INFO;

// predeclarations of local functions:
INT   sm_send_rcv(SM_INFO *info, char *cmd, char *str);
INT   sm_send(SM_INFO *info, char *cmd);
void  sm_no_connection(SM_INFO *info, INT value);
float sm_read_potmeter(SM_INFO *info);

// global variable
SM_INFO *info; 

/*---- support routines --------------------------------------------*/
INT sm_send_rcv(SM_INFO *info, char *cmd, char *str)
{
  char tmpstr[128];
  INT status, i;
  char msg[256];

  if (!info->bd_connected) { // bus driver not connected at the moment
    return 0;
  }

  status = 0;
  i      = 0;
  do {
    BD_PUTS(cmd);
    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO,"sm_send_rcv", "sm_send_rcv: trial %d, cmd = %s", i, cmd);
    }
    status = BD_GETS(tmpstr, sizeof(tmpstr), "\r\n", SM_TIME_OUT);
    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO,"sm_send_rcv", "sm_send_rcv: trial %d, status = %d, str = %s", i, status, tmpstr);
    }
    i = i + 1;
    
    if (status<=0) {
      ss_sleep(SM_WAIT);
    }
  } while ((status<=0) && (i<SM_MAX_TRY));

  if (i==SM_MAX_TRY) {
    cm_msg(MINFO, "sm_send_rcv", "sm_send_rcv: %d time Time_out after sending %s", i, cmd);
    sm_no_connection( info, 1 );     // kill any further action
    //  set alarm
    sprintf( msg, "Steppermotor of Transferline does not respond");
    al_trigger_alarm("sm_send_rcv", msg, "Warning", msg, AT_INTERNAL);
    return status;
  }

  strcpy(str, tmpstr);
  return status;
}


/*---- support routines --------------------------------------------*/
INT sm_send(SM_INFO *info, char *cmd)
{

  if (!info->bd_connected) { // bus driver not connected at the moment
    return 0;
  }

  BD_PUTS(cmd);

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO,"sm_send", "sm_send: str = %s",  cmd);
  }

  ss_sleep(100);   // to leat the steppermotor control digest the command.  

  return FE_SUCCESS;
}

/*------------------------------------------------------------------*/
void sm_no_connection(SM_INFO *info, INT value)
{
  db_set_data(info->hDB, info->hkey_no_connection, &value, sizeof(value), 1, TID_INT);
  if (value == 0) { 
    info->bd_connected = 1;
  } else {
    info->bd_connected = 0;
  }
}

/*------------------------------------------------------------------*/
int check_serialnumber_and_maxima(SM_INFO *info)
{
  char     res[256];
  char     s[256];
  int      l_serial   = 17;
  int      stat;

  if (info->bd_connected == 0) {
    return -999;
  }

  sprintf( s, "PRINT SER\r\n");
  stat = sm_send_rcv(info, s, res);                // get reponse

  if ( stat < 1 ) {
    cm_msg(MERROR,"sm_check_serialnumber", "sm_check_serialnumber: no response, stat = %d", stat);
    return 1;
  }
  cm_msg(MINFO,"sm_check_serialnumber", "sm_check_serialnumber: %s", res);

  if ((stat != l_serial) || (res[14] != 'A')) {
    return 2;
  }

  // set correct holding current
  sprintf(s, "MHC=%e\r\n", info->sm_settings.individual[info->sm_in_use].mhc);
  sm_send(info, s);
  ss_sleep(100);   // to leat the steppermotor control digest the command.

  return 0;
}

/*------------------------------------------------------------------*/
float sm_read_position(SM_INFO *info)
{
  char     res[256];
  char     s[256];
  int      stat = 0;
  float    position = 9.999e+11;

  if (info->bd_connected == 0) {
    return position;
  }

  sprintf( s, "PRINT POS\r\n");
  stat = sm_send_rcv(info, s, res);
  if (stat > 0) {
    position = atof(res);
  }

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO, "sm_read_position", "sm_read_position: position = %e", position );
  }

  return position;
}

/*------------------------------------------------------------------*/
float sm_read_velocity(SM_INFO *info)
{
  char     res[256];
  char     s[256];
  int      stat = 0;
  float    velocity = 9.999e+11;

  if (info->bd_connected == 0) {
    return velocity;
  }

  sprintf( s, "PRINT VM\r\n");
  stat = sm_send_rcv(info, s, res);
  if (stat > 0) {
    velocity = atof(res);
  }

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO, "sm_read_velocity", "sm_read_velocity: velocity = %e", velocity );
  }

  return velocity;
}


/*---- device driver routines --------------------------------------*/
INT sm_in_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  INT   status, i;
  int   size = sizeof(float);
  HNDLE hDB, hkeydd;
  float value;
  int   ivalue;
  int   isize = sizeof(int);

  cm_get_experiment_database(&hDB, NULL);

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

  // create SM internal record
  status = db_create_record(hDB, hKey, "DD/Internal", SM_INTERNAL_STR);
  if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
    cm_msg(MINFO, "sm_in_init", "sm_in_init: start init, create internal record DD = %d", status);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }

  // find SM DD record
  cm_msg(MINFO, "sm_in_init", "sm_in_init: start init, db_find_DD = %d",
                 db_find_key(hDB, hKey, "DD", &hkeydd));
  cm_yield(0);
  status = db_open_record(hDB, hkeydd, (void *)&info->sm_settings, sizeof(SM_SETTINGS), MODE_READ,
                          NULL, NULL);
  if (status != DB_SUCCESS) {
    cm_msg(MINFO, "sm_in_init", "sm_in_init: start init, open record DD = %d", status);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }


  cm_msg(MINFO, "sm_in_init", "sm_in_init: read_back_device = %s", info->sm_settings.read_back_device);
  cm_yield(0);

  if (strstr(info->sm_settings.read_back_device, "K2700")) { // reading voltage via K2700 channel C3
    // allocate memory for data
    info->data = (float *)malloc(SM_K2700_CH*sizeof(float));
    if (info->data == NULL) {
      cm_msg(MERROR, "sm_in_init", "sm_in_init: couldn't allocate data memory.");
      cm_yield(0);
      info->startup_error = 1;
      return FE_SUCCESS;
    }

    // open hot-links to LS340 raw voltage 5 (is channel C3)
    db_find_key(hDB, 0, "/Equipment/K2700/Variables/Input", &hkeydd);
    db_open_record(hDB, hkeydd, (void *)info->data, SM_K2700_CH*sizeof(float), MODE_READ, NULL, NULL);

    info->signature = info->data[SM_K2700_SIG_CH];
    info->sm_in_use = -1;
    
    for (i=0; i<5; i++) {
      if (fabs( info->signature - info->sm_settings.individual[i].signature ) < 0.2) {
        info->sm_in_use = i;
      }
    }

    if (info->sm_in_use >= 0) {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init:  You are using transferline %d ", info->sm_in_use);
      cm_yield(0);
    } else {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init:  No valid signature found" );
      cm_yield(0);
      info->startup_error = 1;
      return FE_SUCCESS;
    }

    info->voltage = info->data[SM_K2700_POT_CH];

    if (SM_DEBUG) {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: initial values : %e", info->voltage );
      cm_yield(0);
    }
  } else if (strstr(info->sm_settings.read_back_device, "SCS900")) { // reading voltage via SCS-900, ADC1-2
    // allocate memory for data
    info->data = (float *)malloc(SM_SCS900_CH*sizeof(float));
    if (info->data == NULL) {
      cm_msg(MERROR, "sm_in_init", "sm_in_init: couldn't allocate data memory.");
      cm_yield(0);
      info->startup_error = 1;
      return FE_SUCCESS;
    }

    // open hot-links to SCS900 input
    db_find_key(hDB, 0, "/Equipment/SCS900/Variables/Input",  &hkeydd);
    db_open_record(hDB, hkeydd, (void *)info->data, SM_SCS900_CH*sizeof(float), MODE_READ, NULL, NULL);

    info->signature = info->data[SM_SCS900_SIG_CH];
    info->sm_in_use = -1;
    
    for (i=0; i<5; i++) {
      if (fabs( info->signature - info->sm_settings.individual[i].signature ) < 0.2) {
        info->sm_in_use = i;
      }
    }

    if ( info->sm_in_use >= 0 ) {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: You are using transferline %d ", info->sm_in_use);
      cm_yield(0);
    } else {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: No valid signature found" );
      cm_yield(0);
      info->startup_error = 1;
      return FE_SUCCESS;
    }

    info->voltage = info->data[SM_SCS900_POT_CH];

    if (SM_DEBUG) {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: initial values : %e", info->voltage);
      cm_yield(0);
      cm_msg(MINFO, "sm_in_init", "sm_in_int: SCS900/Variables/Input %d ? %d, %e",
             status, DB_SUCCESS, info->data[SM_SCS900_POT_CH]);
      cm_yield(0);
    }
  } else if (strstr(info->sm_settings.read_back_device, "SCS2001M")) {
    // allocate memory for data
    info->data = (float *)malloc(SM_SCS2001M_CH*sizeof(float));
    if (info->data == NULL) {
      cm_msg(MERROR, "sm_in_init", "sm_in_init: couldn't allocate data memory.");
      cm_yield(0);
      info->startup_error = 1;
      return FE_SUCCESS;
    }

    // open hot-links to SCS2001M input
    db_find_key(hDB, 0, "/Equipment/SCS2001M/Variables/Input",  &hkeydd);
    db_open_record(hDB, hkeydd, (void *)info->data, SM_SCS2001M_CH*sizeof(float), MODE_READ, NULL, NULL);

    info->signature = info->data[SM_SCS2001M_SIG_CH];
    info->sm_in_use = -1;

    for (i=0; i<5; i++) {
      if (fabs( info->signature - info->sm_settings.individual[i].signature ) < 0.2) {
        info->sm_in_use = i;
      }
    }

    if ( info->sm_in_use >= 0 ) {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: You are using transferline %d ", info->sm_in_use);
      cm_yield(0);
    } else {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: No valid signature found" );
      cm_yield(0);
      info->startup_error = 1;
      return FE_SUCCESS;
    }

    info->voltage = info->data[SM_SCS2001M_POT_CH];

    if (SM_DEBUG) {
      cm_msg(MINFO, "sm_in_init" ,"sm_in_init: initial values : %e", info->voltage);
      cm_yield(0);
      cm_msg(MINFO, "sm_in_init", "sm_in_int: SCS2001M/Variables/Input %d ? %d, %e",
             status, DB_SUCCESS, info->data[SM_SCS2001M_POT_CH]);
      cm_yield(0);
    }
  } else { // neither K2700 nor SCS900
    info->sm_in_use = -1;      // read_back_device not found, so apparently steppermotor not 'in_use'
    return FE_SUCCESS;
  }

  // open hot-link to Needle_Valve(setpoint)
  db_find_key(hDB, 0,"/Equipment/SampleCryo/Variables/Output", &hkeydd);
  info->modus = 0;  // default value
  db_get_data_index(hDB, hkeydd, (void *)&value, &size, info->sm_settings.intern.odb_offset+1, TID_FLOAT);
  info->modus = (int) value;

  // initialize "present setpoint from potmeter reading".
  info->setpoint = sm_read_potmeter(info);

  cm_msg(MINFO,"sm_in_init", "sm_in_init: present setpoint = %e", info->setpoint);
  cm_yield(0);

  size = sizeof(float);
  db_get_data_index(hDB, hkeydd, (void *)&value, &size, info->sm_settings.intern.odb_offset, TID_FLOAT);
  if (SM_DEBUG) {
    cm_msg(MINFO,"sm_in_init","sm_in_init: Demand value = %e", value);
    cm_yield(0);
  }

  if (fabs( value - info->setpoint ) > SM_ACCURACY) {
    cm_msg(MINFO,"sm_in_init", "sm_in_init: Will change demand value from %e to %e",
           value, info->setpoint);
    cm_yield(0);
    db_set_data_index(hDB, hkeydd, (void *)&info->setpoint, sizeof(float), info->sm_settings.intern.odb_offset, TID_FLOAT);
  }

  // initialize driver0
  info->hDB                   = hDB;
  info->hkey                  = hKey;
  info->bd                    = bd;
  sprintf( info->sm_in_name, "Needle valve (read_back)");
  sprintf( info->sm_out_name,"Needle valve (Set Point)");
  sprintf( info->sm_modus_name, "NV: R(0), RW(1), A(2), PID(3)");
  info->startup_error         = 0;
  info->bd_connected          = 0;
  info->last_reconnect        = ss_time();
  info->first_bd_error        = 1;
  info->last_set_time         = 0;   // otherwise the first call to set fails (at initialization)

  // find bd connected dd entry
  status = db_find_key(hDB, hKey, "DD/Internal/No Connection", &info->hkey_no_connection);

  if (!bd) {
    cm_msg(MERROR, "sm_in_init" , "sm_in_init: couldn't establish the bus driver connection.");
    cm_yield(0);
    return FE_SUCCESS;
  }

  if (SM_DEBUG) {
    cm_msg(MINFO,"sm_in_init" , "sm_in_init: Found:  DD/Internal/No Connection");
    cm_yield(0);
  }

  if (info->modus == 0) { // if modus is read-only stop here
    return FE_SUCCESS;  
  }

  if (info->modus == 3) {
    if (info->FromAutoPress == 0) {
      // signal AutoPress to stop
      db_find_key(info->hDB, info->hkey,"DD/ToAutoPress", &hkeydd);
      ivalue = 1;
      db_set_data(info->hDB, hkeydd, (void *)&ivalue, isize, 1, TID_INT);
      status = 0;
      // wait for AutoPress to answer
      while ((status < 5) && (info->FromAutoPress == 0)) {
        status = status + 1;
      }
      if (status < 5) {
        cm_msg(MINFO,"sm_init","sm_init: Activated AutoPress");
        cm_yield(0);
      } else {
        cm_msg(MINFO,"sm_init","sm_init: AutoPress could not be activated");
        cm_yield(0);
      }
    } else {
      cm_msg(MINFO,"sm_init","sm_init: AutoPress could not be activated, while it is not running");
      cm_yield(0);
    }
    return FE_SUCCESS;         // directly into PID, so stop here
  }

  // initialize bus driver
  status = info->bd(CMD_INIT, hKey, &info->bd_info);
  if (status != FE_SUCCESS) {
    info->startup_error = 1;
    return status;
  }

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO,"sm_in_init", "sm_in_init: Bus driver initialized.");
    cm_yield(0);
  }
  
  // set bd connected flag in DD entry
  sm_no_connection(info, 0);

  // check the serial_number and the maximum currents of the motor-drive.
  // if NOT OK set no_connection TRUE so that no further commands will be send
  status = check_serialnumber_and_maxima(info);
  if (status != 0) {
    cm_msg(MERROR, "sm_in_init", "sm_in_int: ERROR: check_serial_number_and_maxima = %d", status);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  } else {
    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO, "sm_in_init", "sm_in_int: INFO: check_serial_number_and_maxima = %d", status);
      cm_yield(0);
    }
  }


  // initialize present position
  info->position  = sm_read_position(info);

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO,"sm_in_init", "sm_in_int: Initial position = %e", info->position);
    cm_yield(0);
  }
  
  // initialize maximum velocity
  info->velocity  = sm_read_velocity(info);

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO,"sm_in_init", "sm_in_int: Initial velocity = %e", info->velocity);
    cm_yield(0);
  }

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT sm_out_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  HNDLE hDB;

  cm_get_experiment_database(&hDB, NULL);

  *pinfo = info;

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT sm_set(SM_INFO *info, float setpoint)
{
  char   cmd[128], str[128];
  float  position, value, target;
  int    status, ii, delay;

  // check for startup error's, if present get out of here
  if (info->startup_error) {
    ss_sleep(10); // to keep CPU happy
    return FE_SUCCESS;
  }

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO, "SM_set", "SM_set entered to set %f  percent", setpoint);
  }

  // if not in_use quit
  if ((info->sm_in_use < 0) || (info->modus == 0) || (info->modus == 3)) {
    return FE_SUCCESS;
  }

  // check if they where too many reconnection failures
  if (info->reconnection_failures > SM_MAX_RECONNECTION_FAILURE) {
    if (info->reconnection_failures == SM_MAX_RECONNECTION_FAILURE+1) {
      cm_msg(MERROR, "SM_set", "too many reconnection failures in sm_set, bailing out :-(");
      info->reconnection_failures++;
    }
    return FE_SUCCESS;
  }

  if (info->sm_settings.intern.scw_in_use) { // slowcontrol watchdog in use
    // feed slowcontrol watchdog
    info->scw.last_updated = ss_time();
    lem_scw_update(&info->scw);
  }

  // if disconnected, try to reconnect after a timeout
  if (info->bd_connected == 0) {
    if (ss_time()-info->last_reconnect > SM_RECONNECTION_TIMEOUT) { // timeout expired
      if (info->sm_settings.intern.detailed_msg) {
        cm_msg(MINFO, "SM_set", "Steppermotor: reconnection trial ...");
      }
      status = info->bd(CMD_INIT, info->hkey, &info->bd_info);
      if (status != FE_SUCCESS) {
        info->reconnection_failures++;
        if (info->sm_settings.intern.detailed_msg)
          cm_msg(MINFO, "SM_set", "Steppermotor: reconnection attempted failed");
        return FE_SUCCESS;
      } else {
        info->bd_connected = 1; // bus driver is connected again
        info->last_reconnect = ss_time();
        info->reconnection_failures = 0;
        info->first_bd_error = 1;
        if (info->sm_settings.intern.detailed_msg) {
          cm_msg(MINFO, "SM_get", "Steppermotor: successfully reconnected");
        }
      }
    } else { // timeout still running
      ss_sleep(10); // to keep CPU happy 
      return FE_SUCCESS;
    }
  }

  // if to quick after last set: do nothing for the impatient user
  if ( ss_time() - info->last_set_time < SM_TIME_BETWEEN_SETS ) {
    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO,"SM_set","SM_set: too less time between the set commands");
    }
    ss_sleep(10); // to keep CPU happy 
    return FE_SUCCESS;
  }

  info->last_set_time = ss_time();

  value = sm_read_potmeter(info);

  if ((value < -20.0) || (value > 110.0)) {
    cm_msg(MINFO, "sm_set", "sm_set: potmeter reading out range: value = %e", value);
    sprintf( str, "Potentiometer reading out of range, value = %e", value);
    al_trigger_alarm("sm_set", str, "Warning", str, AT_INTERNAL);
    return FE_SUCCESS;
  }

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO,"sm_set", "sm_set: Changing the NeedleValve from %e to %e percent opening",
           value, setpoint);
  }

  if (fabs(value - info->setpoint) > SM_ACCURACY) {
    cm_msg(MINFO, "sm_set",
    "sm_set: position of the needle valve potentiometer has been changed, it was %e and is now %e !!",
     info->setpoint, value );
    cm_msg(MINFO, "sm_set", "sm_set: assuming %e to be correct !!", value );
//
    sprintf( str, "Transferline_Needle_Valve has been changed manually ?");
//    al_trigger_alarm("sm_set", str, "Warning", str, AT_INTERNAL);
    info->setpoint = value;
  }

  position = sm_read_position(info);

  if ((fabs(position) < 0.001) && (fabs(info->position) > 0.001)) {
    sprintf( str, "sm_set: Steppermotor drive has been without power !!");
    al_trigger_alarm("sm_set", str, "Warning", str, AT_INTERNAL);
    cm_msg(MINFO, "sm_set", "sm_set: Steppermotor drive has been without power !!");
    info->position = 0.0;
  }


  if ((fabs( position - info->position ) > 0.1) && (fabs(position) > 0.001)) {
    cm_msg(MINFO, "sm_set",
      "sm_set: position of the needle motor has been changed unexpectively, it was %e and is now %e !!",
      info->position, position);
  }
  info->position = position;
    

  // after all these checks finally come to business

  if ((setpoint < -10.0) || (setpoint > 110.0)) {
    cm_msg(MINFO, "sm_set", "sm_set: setpoint out range: setpoint = %e", setpoint);
    sprintf( str, "Transferline setpoint reading out of range, value = %e", setpoint);
    al_trigger_alarm("sm_set", str, "Warning", str, AT_INTERNAL);
    return FE_SUCCESS;
  }
  
  // set currents
  if (setpoint > info->setpoint) {     // opening valve
    sprintf(cmd, "MAC=%f\r\n", info->sm_settings.individual[info->sm_in_use].mac_open);
    sm_send(info, cmd);
    sprintf(cmd, "MRC=%f\r\n", info->sm_settings.individual[info->sm_in_use].mrc_open);
    sm_send(info, cmd);
  } else {
    sprintf(cmd, "MAC=%f\r\n", info->sm_settings.individual[info->sm_in_use].mac_close);
    sm_send(info, cmd);
    sprintf(cmd, "MRC=%f\r\n", info->sm_settings.individual[info->sm_in_use].mrc_close);
    sm_send(info, cmd);
  }

  // calculate relative movement in degrees
  value = info->sm_settings.individual[info->sm_in_use].valve_range * ( (setpoint - info->setpoint) / 100.0 );
  sprintf( cmd, "MOVR %f\r\n", value);
  target = position + value;

  if (info->sm_settings.intern.detailed_msg) {
    cm_msg(MINFO, "sm_set", "sm_set: Sending:  %s", cmd);
  }

  sm_send(info, cmd);

  //  wait until ready

  // calculate waittime based on velocity and stap + 20 in untis of 0.5 second.
  delay = 2 * (int) (fabs(value) / info->velocity) + 20; 
  ii = 0;
  while ((ii < delay) && (fabs(target - sm_read_position(info)) > 5.0)) {
    ss_sleep(500);
    ii = ii + 1;
    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO," sm_set","sm_set: needlvevalve moved to %.2f degrees in %.1f seconds reaching %.2f percent",
             sm_read_position(info), (float) ii/2.0, target);
    }
  }
  
  if (ii < delay) {
    info->position = sm_read_position(info);
    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO," sm_set","sm_set: needlvevalve moved by %.2f degrees in %.1f seconds to %.2f percent",
             value, (float) ii/2.0, setpoint);
    }
  } else {
    info->position = -9.9E+11;
    cm_msg(MINFO," sm_set",
      "sm_set: needlvevalve could not be moved by %.2f degrees in %.1f seconds", value, ((float) delay/2.0) );
    sprintf( str, "needlvevalve could not be moved by %.2f degrees in %0.1f seconds", value, ((float) delay/2.0) );
    al_trigger_alarm("sm_set", str, "Warning", str, AT_INTERNAL);
  }

  info->setpoint = setpoint;

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT sm_get(SM_INFO *info, float *pvalue)
{
  // check for startup error's, if present get out of here
  if (info->startup_error) {
    ss_sleep(10); // to keep CPU happy
    return FE_SUCCESS;
  }
  
  if (info->sm_in_use >= 0 ) {
    *pvalue = sm_read_potmeter(info);
     if ((*pvalue < -20.0) || (*pvalue > 120.0)) {
       *pvalue = *pvalue - 1000.0;
     }
  } else {
    *pvalue = -300.0;
  }

  if (SM_DEBUG) {
    cm_msg(MINFO, "sm_get", "sm_get: Getting value = %e", *pvalue);
  }

  ss_sleep(10);

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
 float sm_read_potmeter(SM_INFO *info)
 {
   float  value;

   if (strstr(info->sm_settings.read_back_device, "K2700")) {
     info->voltage = info->data[SM_K2700_POT_CH];
   } else if (strstr(info->sm_settings.read_back_device, "SCS900")) {
     info->voltage = info->data[SM_SCS900_POT_CH];
   } else if (strstr(info->sm_settings.read_back_device, "SCS2001M")) {
     info->voltage = info->data[SM_SCS2001M_POT_CH];
   }

   value = info->sm_settings.individual[info->sm_in_use].pcurve[0] +
           info->sm_settings.individual[info->sm_in_use].pcurve[1] * info->voltage +
           info->sm_settings.individual[info->sm_in_use].pcurve[2] * info->voltage * info->voltage;

   if (SM_DEBUG) {
     cm_msg(MINFO, "sm_read_potmeter", "sm_read_potmeter: voltage = %e,  value = %e", info->voltage, value);
   }

   return value;
 }


/*----------------------------------------------------------------------------------*/
INT sm_out_get_default_name(SM_INFO *info, INT channel, char *name)
{
  if (channel == 0) {
    strncpy(name, info->sm_out_name, sizeof(name));
  }
  
  if (channel == 1) {
    strncpy(name, info->sm_modus_name, sizeof(name));
  }
  
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------------*/
INT sm_in_get_default_name(SM_INFO *info, INT channel, char *name)
{
  strncpy(name, info->sm_in_name, sizeof(name));
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT sm_switch(SM_INFO *info, float floatmodus)
{
 int    status;
 HNDLE  hkeydd;
 float  value;
 int    ivalue;
 int    size  = sizeof(float);
 int    isize = sizeof(int);
 int    modus;

 modus = (int) floatmodus;

  if (info->startup_error || info->sm_in_use < 0 ) {
    ss_sleep(10); // keeps the CPU happy
    return FE_SUCCESS;
  }  


  // info->modus == 3 then  deactivate AutoPress
  if ((info->modus == 3) && (info->FromAutoPress == 1)) {
    // signal AutoPress to stop
    db_find_key(info->hDB, info->hkey,"DD/ToAutoPress", &hkeydd);
    ivalue = 0;
    db_set_data(info->hDB, hkeydd, (void *)&ivalue, sizeof(ivalue), 1, TID_INT);
    status = 0;
    // wait for AutoPress to answer
    while ((status < 5) && (info->FromAutoPress > 0)) {
      status = status + 1;
    }
    if ( status < 5 ) {
      cm_msg(MINFO,"sm_switch","sm_switch: Deactivated AutoPress");
    } else {
      cm_msg(MINFO,"sm_switch","sm_switch: AutoPress could not be deactivated");
    }
  }

  // Steppermotor should go to read_only mode
  if (modus == 0) {
    switch (info->modus) {
      case 1 :  
        cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from read-write to read-only");
        break;
      case 2 :  
        cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from auto to read-only");
        break;
      case 3 :  
        cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from PID to read-only");
        break;
      default:
        break;
    }

    // disconnect bus (if info->modus == 3 it should already be disconnected, but anyway
    if (info->bd_connected) {
      info->bd(CMD_EXIT, info->bd_info);
    }
    sm_no_connection(info, 1);
  }  // end of modus = 0


  // Steppermotor should go from read_only or PID to write or auto
  if ((info->modus == 0 || info->modus == 3) && (modus == 1 || modus == 2)) {
    if (info->modus == 0 && modus == 1)
      cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from read-only to read-write");
    if (info->modus == 0 && modus == 2)
      cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from read-only to auto");
    if (info->modus == 3 && modus == 1)
      cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from PID to read-write");
    if (info->modus == 3 && modus == 2)
      cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from PID to auto");

    // open hot-link to Needle_Valve(setpoint)
    db_find_key(info->hDB, 0,"/Equipment/SampleCryo/Variables/Output", &hkeydd);

    // initialize "present setpoint from potmeter reading".
    info->setpoint = sm_read_potmeter(info);

    cm_msg(MINFO,"sm_switch", "sm_switch: present setpoint = %e", info->setpoint);

    size = sizeof(float);
    db_get_data_index(info->hDB, hkeydd, (void *)&value, &size, info->sm_settings.intern.odb_offset, TID_FLOAT);
    if (SM_DEBUG) cm_msg(MINFO,"sm_switch","sm_switch: Demand value = %e", value);

    if ( fabs( value - info->setpoint ) > SM_ACCURACY ) {
      cm_msg(MINFO,"sm_in_switch", "sm_switch: Will change demand value from %e to %e",
             value, info->setpoint);
      db_set_data_index(info->hDB, hkeydd, (void *)&info->setpoint, sizeof(float), info->sm_settings.intern.odb_offset, TID_FLOAT);
    }

    // initialize bus driver
    status = info->bd(CMD_INIT, info->hkey, &info->bd_info);
    if (status != FE_SUCCESS) {
      info->startup_error = 1;
      return status;
    }

    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO,"sm_switch", "sm_switch: Bus driver initialized.");
    }

    // set bd connected flag in DD entry
    sm_no_connection(info, 0);

    // check the serial_number and the maximum currents of the motor-drive.
    // if NOT OK set no_connection TRUE so that no further commands will be send
    status = check_serialnumber_and_maxima(info);
    if ( status != 0 ) {
      cm_msg(MERROR, "sm_switch", "sm_switch: ERROR: check_serial_number_and_maxima = %d", status);
      info->startup_error = 1;
      return FE_SUCCESS;
    } else {
      if (info->sm_settings.intern.detailed_msg)
        cm_msg(MINFO,
        "sm_switch", "sm_switch: INFO: check_serial_number_and_maxima = %d", status);
    }


    // initialize present position
    info->position  = sm_read_position(info);

    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO,"sm_switch", "sm_switch: Initial position = %e", info->position);
    }

    // initialize maximum velocity
    info->velocity  = sm_read_velocity(info);

    if (info->sm_settings.intern.detailed_msg) {
      cm_msg(MINFO,"sm_switch", "sm_switch: Initial velocity = %e", info->velocity);
    }

  }  // end of modus = 1 or modus = 2

  // Steppermotor should go from auto to read-write
  if ((info->modus == 2) && (modus == 1)) {
    cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from auto to read-write");
  }

  // Steppermotor should go from read-write to auto
  if ((info->modus == 1) && (modus == 2)) {
    cm_msg(MINFO,"sm_switch","sm_switch: Setting steppermotor from read-write to auto");
  }


  // modus == 3 then  activate AutoPress
  if (modus == 3) {
    // disconnect bus (if info->modus == 0 it should already be disconnected, but anyway
    if (info->bd_connected) {
      info->bd(CMD_EXIT, info->bd_info);
    }
    sm_no_connection(info, 1);

    if (info->FromAutoPress == 0) {
      // signal AutoPress to stop
      db_find_key(info->hDB, info->hkey,"DD/ToAutoPress", &hkeydd);
      ivalue = 1;
      db_set_data(info->hDB, hkeydd, (void *)&ivalue, isize, 1, TID_INT);
      status = 0;
      // wait for AutoPress to answer
      while ((status < 5) && (info->FromAutoPress == 0)) 
        status = status + 1;
      if (status < 5) {
        cm_msg(MINFO,"sm_switch","sm_switch: Activated AutoPress");
      } else {
        cm_msg(MINFO,"sm_switch","sm_switch: AutoPress could not be activated");
      }
    } else {
      cm_msg(MINFO,"sm_switch","sm_switch: AutoPress could not be activated, while it is not running");
    }
  }

  info->modus = modus;
  return FE_SUCCESS;
}


/*----------------------------------------------------------------------------*/
INT sm_exit(SM_INFO *info)
{
  // call EXIT function of bus driver, usually closes device
  if (info->bd_connected) {
    info->bd(CMD_EXIT, info->bd_info);
  }

  free(info->data);
  free(info);

  return FE_SUCCESS;
}



/*---- device driver entry point -----------------------------------*/
INT SM_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  = sm_in_init(hKey, info, channel, bd);
      break;

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

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

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

    default:
      break;
  }

  va_end(argptr);
  return status;
}

INT SM_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  = sm_out_init(hKey, info, channel, bd);
      break;

    case CMD_SET:
      info    = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      value   = (float) va_arg(argptr, double);
      if (channel == 0) status = sm_set(info, value);
      if (channel == 1) status = sm_switch(info, value);
      break;

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

    default:
      break;
  }

  va_end(argptr);

  return status;
}