danfysik.c

Go to the documentation of this file.

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

  Name:         danfysik.c
  Created by:   Andreas Suter  2005/02/28

  Contents:     device driver for danfysik magnet power supply.

  RS232: 9600 baud, 8 data bits, 1 stop bit, no parity,
         protocol: CTS (hardware), termination \r (CR)

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

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

#include "ets_logout.h"

#define DANFYSIK_INIT_ERROR -2
#define DANFYSIK_READ_ERROR -1
#define DANFYSIK_TIME_OUT 2000
#define DANFYSIK_RECONNECTION_TIMEOUT 10

#define DANFYSIK_IN_CH  5
#define DANFYSIK_OUT_CH 4

#define DANFYSIK_ETS_LOGOUT_SLEEP 10000

/* --------- to handle error messages ------------------------------*/
#define DANFYSIK_MAX_READBACK_FAILURE 5
#define DANFYSIK_MAX_EMPTY_READBACK_ERR 10
#define DELTA_TIME_ERROR 3600

/*---- danfysik status decoding tags ---------------------------------*/
#define DANFYSIK_STATUS_OFF                        0x800000
#define DANFYSIK_STATUS_LOCAL                      0x400000
#define DANFYSIK_INTERLOCK_EXT_4                   0x200000
#define DANFYSIK_SPARE_1                           0x100000
#define DANFYSIK_SPARE_2                           0x080000
#define DANFYSIK_SPARE_3                           0x040000
#define DANFYSIK_PERCENTAGE                        0x020000
#define DANFYSIK_INTERLOCK_EXT_1                   0x010000
#define DANFYSIK_STATUS_STANDBY                    0x008000
#define DANFYSIK_INTERLOCK_SUM                     0x004000
#define DANFYSIK_INTERLOCK_DC_OVER_CURRENT         0x002000
#define DANFYSIK_INTERLOCK_OVER_VOLTAGE_PROTECTION 0x001000
#define DANFYSIK_STATUS_ON                         0x000800
#define DANFYSIK_INTERLOCK_EXT_2                   0x000400
#define DANFYSIK_INTERLOCK_MAINS_FAILURE           0x000200
#define DANFYSIK_STATUS_CURRENT_LIMIT              0x000100
#define DANFYSIK_INTERLOCK_EARTH_LEAKAGE_FAILURE   0x000080
#define DANFYSIK_INTERLOCK_CONVERTER_OVER_VOLTAGE  0x000040
#define DANFYSIK_INTERLOCK_MPS_OVERTEMPERATURE     0x000020
#define DANFYSIK_SPARE_4                           0x000010
#define DANFYSIK_SPARE_5                           0x000008
#define DANFYSIK_INTERLOCK_EXT_3                   0x000004
#define DANFYSIK_STATUS_MPS_NOT_READY              0x000002
#define DANFYSIK_INTERLOCK_MPS_FAN_FAULT           0x000001

typedef struct {
  INT   detailed_msg; 
  INT   ets_in_use;   
  char  in_names[DANFYSIK_IN_CH][NAME_LENGTH]; 
  char  out_names[DANFYSIK_OUT_CH][NAME_LENGTH]; 
  float max_current;  
  float max_voltage;  
  DWORD next_read;    
} DANFYSIK_SETTINGS;

#define DANFYSIK_SETTINGS_STR "\
Detailed Messages = INT : 0\n\
ETS_IN_USE = INT : 1\n\
Input Names = STRING[5] : \n\
[32] Remote (read back)\n\
[32] Current Set Value (A) (readback)\n\
[32] Output Voltage (V)\n\
[32] Output Current (A)\n\
[32] Status\n\
Output Names = STRING[4] : \n\
[32] Remote\n\
[32] State (0 off, 1 on, 2 reset)\n\
[32] Set Current (A)\n\
[32] Current Limit (A)\n\
Max. Current = FLOAT : 20.f\n\
Max. Voltage = FLOAT : 75.f\n\
Next Read Attempt (ms) = DWORD : 75\n\
"

typedef struct {
  DANFYSIK_SETTINGS danfysik_settings; 
  INT   num_channels;         
  INT   (*bd)(INT cmd, ...);  
  void  *bd_info;                   
  int   bd_connected;         
  int   first_bd_error;       
  HNDLE hDB;                  
  HNDLE hkey;                 
  INT   danfysik_remote;      
  INT   danfysik_status;      
  INT   errcount;             
  INT   startup_error;        
  INT   empty_readback_error; 
  INT   readback_failure;     
  DWORD lasterrtime;          
  float last_valid_value[DANFYSIK_IN_CH]; 
  DWORD last_reconnect;        
  int   reconnection_failures; 
  float soft_current_limit;    
  DWORD time_to_read;          
} DANFYSIK_INFO;

DANFYSIK_INFO *info;           

/*---- support routines --------------------------------------------*/
void danfysik_strip_rubbish(char *str_in, char *str_clean)
{
  int i;

  for (i=0; i<strlen(str_in); i++)
    if ((str_in[i]>=32) && (str_in[i]<=126))
      break;

  strcpy(str_clean, str_in+i);
}

/*------------------------------------------------------------------*/
INT danfysik_error_read(int channel, char *str)
{
  int  error;
  char err_msg[128];

  // because sometimes not the whole string is given
  error = 0;
  if (channel == 0) { // CMD
    if (strlen(str) != 6)
      error = 1;
  } else if (channel == 1) { // RA
    if (strlen(str) != 8)
      error = 1;
  } else if ((channel > 1) && (channel < 4)) { // AD 2, AD 8
    if (((str[0] != '+') && (str[0] != '-')) || strlen(str) != 8) // read back error
      error = 1;
  } else { // S1H
    if (strlen(str) != 8)
      error = 1;
  }

  if (error) {
    info->empty_readback_error++;
    return 1;
  }

  error = 0;
  if (str[0]=='?') { // error
    strcpy(err_msg, "Communication/Command Error");
    info->errcount++;
    if (info->danfysik_settings.detailed_msg)
      cm_msg(MERROR, "danfysik_error_read", err_msg);
    return 1;
  } else
    return 0;
}

/*------------------------------------------------------------------*/
void danfysik_decode_status(DANFYSIK_INFO *info, char *str)
{
  int status;

  if (strlen(str)==0) {
    info->empty_readback_error++;
    return;
  }

  sscanf(str, "%x", &status);

  // for debugging only, needs to be removed asap
  if ((str[0] == '-') || (str[0] == '+')) {
    return;
  }

  // for debugging only, needs to be removed asap
/*
  if (status & 0x21F7FF)
    cm_msg(MDEBUG, "danfysik_decode_status", "debug> str='%s', status=%d", str, status);
*/
  
  if (status & DANFYSIK_STATUS_OFF) {
    if (!(info->danfysik_status & DANFYSIK_STATUS_OFF)) // previous status != DANFYSIK_STATUS_OFF
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Status changed to Off.");
  }
  
  if (status & DANFYSIK_STATUS_LOCAL) {
    if (!(info->danfysik_status & DANFYSIK_STATUS_LOCAL)) // previous status != DANFYSIK_STATUS_LOCAL
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Status changed to Local.");
  }
  
  if (status & DANFYSIK_INTERLOCK_EXT_4) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_EXT_4)) // previous status != DANFYSIK_INTERLOCK_EXT_4
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Ext Interlock 4 fired.");
  }
  
  if (status & DANFYSIK_PERCENTAGE) {
    if (!(info->danfysik_status & DANFYSIK_PERCENTAGE)) // previous status != DANFYSIK_PERCENTAGE
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Shows Percentage instead of A/V.");
  }
  
  if (status & DANFYSIK_INTERLOCK_EXT_1) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_EXT_1)) // previous status != DANFYSIK_INTERLOCK_EXT_1
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Ext Interlock 1 (Magnet Thermo Switch) fired.");
  }
  
  if (status & DANFYSIK_STATUS_STANDBY) {
    if (!(info->danfysik_status & DANFYSIK_STATUS_STANDBY)) // previous status != DANFYSIK_STATUS_STANDBY
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Status changed to Standby Mode.");
  }
  
  if (status & DANFYSIK_INTERLOCK_DC_OVER_CURRENT) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_DC_OVER_CURRENT)) // previous status != DANFYSIK_INTERLOCK_DC_OVER_CURRENT
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: DC Over Current Interlock fired.");
  }
  
  if (status & DANFYSIK_INTERLOCK_OVER_VOLTAGE_PROTECTION) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_OVER_VOLTAGE_PROTECTION)) // previous status != DANFYSIK_INTERLOCK_OVER_VOLTAGE_PROTECTION
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Over Voltage Protection Interlock fired.");
  }
  
  if (status & DANFYSIK_STATUS_ON) {
    if (!(info->danfysik_status & DANFYSIK_STATUS_ON)) // previous status != DANFYSIK_STATUS_ON
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Status changed to On.");
  }
  
  if (status & DANFYSIK_INTERLOCK_EXT_2) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_EXT_2)) // previous status != DANFYSIK_INTERLOCK_EXT_2
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Ext Interlock 2 fired.");
  }
  
  if (status & DANFYSIK_INTERLOCK_MAINS_FAILURE) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_MAINS_FAILURE)) // previous status != DANFYSIK_INTERLOCK_MAINS_FAILURE
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Mains Failure Interlock fired.");
  }
  
  if (status & DANFYSIK_STATUS_CURRENT_LIMIT) {
    if (!(info->danfysik_status & DANFYSIK_STATUS_CURRENT_LIMIT)) // previous status != DANFYSIK_STATUS_CURRENT_LIMIT
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: At Current Limit.");
  }
  
  if (status & DANFYSIK_INTERLOCK_EARTH_LEAKAGE_FAILURE) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_EARTH_LEAKAGE_FAILURE)) // previous status != DANFYSIK_INTERLOCK_EARTH_LEAKAGE_FAILURE
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Earth Leakage Failure Interlock fired.");
  }
  
  if (status & DANFYSIK_INTERLOCK_CONVERTER_OVER_VOLTAGE) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_CONVERTER_OVER_VOLTAGE)) // previous status != DANFYSIK_INTERLOCK_CONVERTER_OVER_VOLTAGE
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Converter Over Voltage Interlock fired.");
  }
  
  if (status & DANFYSIK_INTERLOCK_MPS_OVERTEMPERATURE) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_MPS_OVERTEMPERATURE)) // previous status != DANFYSIK_INTERLOCK_MPS_OVERTEMPERATURE
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: MPS Overtemperature Interlock fired.");
  }
  
  if (status & DANFYSIK_INTERLOCK_EXT_3) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_EXT_3)) // previous status != DANFYSIK_INTERLOCK_EXT_3
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Ext Interlock 3 fired.");
  }
  
  if (status & DANFYSIK_STATUS_MPS_NOT_READY) {
    if (!(info->danfysik_status & DANFYSIK_STATUS_MPS_NOT_READY)) // previous status != DANFYSIK_STATUS_MPS_NOT_READY
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: Status changed to MPS not ready.");
  }
  
  if (status & DANFYSIK_INTERLOCK_MPS_FAN_FAULT) {
    if (!(info->danfysik_status & DANFYSIK_INTERLOCK_MPS_FAN_FAULT)) // previous status != DANFYSIK_INTERLOCK_MPS_FAN_FAULT
      cm_msg(MINFO, "danfysik_decode_status", "Danfysik Power Supply: MPS Fan Fault Interlock fired.");
  }
  
  info->danfysik_status = status;
}

/*---- device driver routines --------------------------------------*/
INT danfysik_in_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  INT   status, size;
  char  str[256], str2[256], str3[256], str_clean[256];
  HNDLE hDB, hkeydd;

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

  cm_get_experiment_database(&hDB, NULL);

  // create Danfysik settings record
  status = db_create_record(hDB, hKey, "DD", DANFYSIK_SETTINGS_STR);
  if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
    cm_msg(MERROR, "danfysik_init", "danfysik_init: Error creating Danfysik DD record in ODB, status=%d", status);
    cm_yield(0);
    return FE_ERR_ODB;
  }

  db_find_key(hDB, hKey, "DD", &hkeydd);
  size = sizeof(info->danfysik_settings);
  db_get_record(hDB, hkeydd, &info->danfysik_settings, &size, 0);

  // initialize driver
  info->num_channels          = channels;
  info->bd                    = bd;
  info->hDB                   = hDB;
  info->hkey                  = hKey;
  info->errcount              = 0;
  info->startup_error         = 0;
  info->lasterrtime           = ss_time();
  info->danfysik_status       = 0;
  info->empty_readback_error  = 0;
  info->readback_failure      = 0;
  info->last_reconnect        = ss_time();
  info->reconnection_failures = 0;
  info->first_bd_error        = 1;
  info->soft_current_limit    = +999.0;
  info->time_to_read          = ss_millitime();
  
  if (!bd)
    return FE_ERR_ODB;

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

  // initialize Danfysik
  cm_msg(MINFO, "danfysik_init", "initialize danfysik.");
  cm_yield(0);
  BD_PUTS("VER\r");
  status = BD_GETS(str, sizeof(str), "\r", DANFYSIK_TIME_OUT);
  status = BD_GETS(str2, sizeof(str), "\r", DANFYSIK_TIME_OUT);
  status = BD_GETS(str3, sizeof(str), "\r", DANFYSIK_TIME_OUT);
  if (status < 0) {
    info->startup_error = 1;
    return FE_SUCCESS;
  }
  cm_msg(MINFO, "danfysik_init", "danfysik sw version:\r %s %s %s", str, str2, str3);
  cm_yield(0);

  // check if local or remote
  BD_PUTS("CMD\r");
  status = BD_GETS(str, sizeof(str), "\r", DANFYSIK_TIME_OUT);
  danfysik_strip_rubbish(str, str_clean);
  if (strstr(str_clean, "LOC")) {  // in local mode
    info->danfysik_remote = 0;
    cm_msg(MINFO, "danfysik_init", "danfysik power supply not in remote mode.");
    cm_yield(0);
  } else if (strstr(str_clean, "REM")) { // in remote mode
    info->danfysik_remote = 1;
  } else { // error
    info->startup_error = 1;
    if (info->danfysik_settings.detailed_msg) {
      cm_msg(MINFO, "danfysik_init", "danfysik read problem: %s", str_clean);
      cm_yield(0);
    }
    return FE_SUCCESS;
  }

  if (info->danfysik_settings.detailed_msg) {
    cm_msg(MINFO, "danfysik_init", "danfysik set to %s", str_clean);
    cm_yield(0);
  }
  
  // check status
  memset(str, 0, sizeof(str));
  BD_PUTS("S1H\r");
  status = BD_GETS(str, sizeof(str), "\r", DANFYSIK_TIME_OUT);
  danfysik_strip_rubbish(str, str_clean);
  danfysik_decode_status(info, str_clean);
  
  if (info->danfysik_settings.detailed_msg) {
    cm_msg(MINFO, "danfysik_init", "danfysik startup status to %s", str);
    cm_yield(0);
  }
  
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT danfysik_out_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  *pinfo = info;

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT danfysik_exit(DANFYSIK_INFO *info)
{
  // call EXIT function of bus driver, usually closes device
  info->bd(CMD_EXIT, info->bd_info);

  free(info);
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT danfysik_set(DANFYSIK_INFO *info, INT channel, float value)
{
  char str[128], str_clean[128];
  INT  ivalue;
  INT  status;


  if (info->startup_error)
    return FE_SUCCESS;

  if (!info->bd_connected) {
    if (info->first_bd_error) {
      info->first_bd_error = 0;
      cm_msg(MINFO, "danfysik_set",
             "set values not possible at the moment, since the bus driver is not available!");
    }
  }

  switch (channel) {
    case 0: // local/remote
      if (value == 0) { // switch to local
        if (info->danfysik_remote != 0) // not already in local mode
          strcpy(str, "LOC\r");
        else // nothing to be done
          return FE_SUCCESS;
      } else if (value == 1) { // switch to remote
        if (info->danfysik_remote != 1) // not already in remote mode
          strcpy(str, "REM\r");
        else // nothing to be done
          return FE_SUCCESS;
      } else { // value out of range, hence ignore it 
        return FE_SUCCESS;
      }
      BD_PUTS(str); // send command
      info->danfysik_remote = value; // keep value
      break;
    case 1: // on/off/reset
      switch ((int)value) {
        case 0: // off
          strcpy(str, "F\r");
          break;
        case 1: // on
          strcpy(str, "N\r");
          break;
        case 2: // reset
          strcpy(str, "RS\r");
          break;
        default: // value out of range, hence ignore it
          return FE_SUCCESS;
      }
      BD_PUTS(str);
      break;
    case 2: // set current
      if (value > info->soft_current_limit) {
        cm_msg(MERROR, "danfysik_set", "Set current value %f > soft current limit %f! Will set soft current limit.",
               value, info->soft_current_limit);
        ivalue = (INT)(info->soft_current_limit*1.0e3);       
      } else {
        ivalue = (INT)(value*1.0e3);
      }  
      if (ivalue > 0)
        sprintf(str, "DA 0,+0%d\r", ivalue);
      else
        sprintf(str, "DA 0,-0%d\r", abs(ivalue));

      BD_PUTS(str);
      status = BD_GETS(str, sizeof(str), "\r", 200);
      danfysik_strip_rubbish(str, str_clean);
      if (strstr(str_clean, "?")) { // wrong command mode
        if (info->danfysik_settings.detailed_msg)
          cm_msg(MERROR, "danfysik_set", "set current: Wrong command mode (local/remote)!");
      }
      break;
    case 3: // set soft-current limit
      info->soft_current_limit = value; // keep soft current limit
      break;
    default:
      return FE_SUCCESS;
  }
  
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT danfysik_in_get_label(DANFYSIK_INFO *info, INT channel, char *name)
{
  strcpy(name, info->danfysik_settings.in_names[channel]);
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT danfysik_out_get_label(DANFYSIK_INFO *info, INT channel, char *name)
{
  strcpy(name, info->danfysik_settings.out_names[channel]);
  return FE_SUCCESS;
}

/*-----------------------------------------------------------------------------*/
INT danfysik_get(DANFYSIK_INFO *info, INT channel, float *pvalue)
{
  char  str[128], cmd[128], str_clean[128];
  INT   status, size;
  INT   value;
  DWORD now, nowtime, difftime;
  HNDLE hkey;

  now = ss_millitime();
  if (now - info->time_to_read < info->danfysik_settings.next_read) {
    ss_sleep(10);
    return FE_SUCCESS;
  }
  info->time_to_read = now;

  // error timeout facility
  nowtime = ss_time();
  difftime = nowtime - info->lasterrtime;
  if ( difftime >  DELTA_TIME_ERROR ) {
    info->errcount = 0;
    info->lasterrtime = ss_time();
  }

  // check if there was a startup error
  if ( info->startup_error ) {
    *pvalue = (float) DANFYSIK_INIT_ERROR;
    ss_sleep(10); // to keep CPU load low when Run active
    return FE_SUCCESS;
  }
 
  if (info->reconnection_failures > 5) {
    *pvalue = (float) DANFYSIK_READ_ERROR;
    if (info->reconnection_failures == 6) {
      if (info->danfysik_settings.detailed_msg)
        cm_msg(MERROR, "danfysik_get", "too many reconnection failures, bailing out :-(");
      info->reconnection_failures++;
    }
    return FE_SUCCESS;
  }

  // if disconnected, try to reconnect after a timeout of a timeout
  if (!info->bd_connected) {
    if (ss_time()-info->last_reconnect > DANFYSIK_RECONNECTION_TIMEOUT) { // timeout expired
      if (info->danfysik_settings.detailed_msg)
        cm_msg(MINFO, "danfysik_get", "Danfysik: reconnection trial ...");
      status = info->bd(CMD_INIT, info->hkey, &info->bd_info);
      if (status != FE_SUCCESS) {
        info->reconnection_failures++;
        *pvalue = (float) DANFYSIK_READ_ERROR;
        if (info->danfysik_settings.detailed_msg)
          cm_msg(MINFO, "danfysik_get", "Danfysik: reconnection attempted failed");
        return FE_ERR_HW;
      } 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->danfysik_settings.detailed_msg)
          cm_msg(MINFO, "danfysik_get", "Danfysik: successfully reconnected");
      }
    } else { // timeout still running
      *pvalue = (float) info->last_valid_value[channel];
      return FE_SUCCESS;
    }
  }

  if (info->soft_current_limit == +999.0) { // soft current limit not set so far
    // get soft current limit from ODB
    db_find_key(info->hDB, 0, "/Equipment/Danfysik/Variables/Output", &hkey);
    size = sizeof(info->soft_current_limit);
    status = db_get_data_index(info->hDB, hkey, &info->soft_current_limit, &size, 3, TID_FLOAT);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "danfysik_init", "danfysik_init: Error reading Danfysik soft current limit, status=%d", status);
      info->soft_current_limit = 20.0;
    }
  }
  
  // get command
  switch (channel) {
    case 0: // read if local or remote
      strcpy(cmd, "CMD\r");
      break;
    case 1: // read set value
      strcpy(cmd, "RA\r");
      break;
    case 2: // read output voltage
      strcpy(cmd, "AD 2\r");
      break;
    case 3: // read output current
      strcpy(cmd, "AD 8\r");
      break;
    case 4: // read status
      strcpy(cmd, "S1H\r");
      break;
    default:
      *pvalue = (float) DANFYSIK_READ_ERROR;
      return FE_SUCCESS;
  }
  
  memset(str, 0, sizeof(str));
  BD_PUTS(cmd);
  status = BD_GETS(str, sizeof(str), "\r", DANFYSIK_TIME_OUT);  
  danfysik_strip_rubbish(str, str_clean);
  
  if (danfysik_error_read(channel, str_clean)) {
    *pvalue = info->last_valid_value[channel];
    if (info->empty_readback_error == DANFYSIK_MAX_EMPTY_READBACK_ERR) {
      cm_msg(MERROR, "danfysik_get", "danfysik_get: cannot get any readback anymore! Check device!");
      *pvalue = (float) DANFYSIK_READ_ERROR;
    }

    info->readback_failure++;

    if (info->readback_failure == DANFYSIK_MAX_READBACK_FAILURE) {
      info->readback_failure = 0; // reset counter
      // try to disconnect and reconnect the bus driver
      if ((ss_time()-info->last_reconnect > DANFYSIK_RECONNECTION_TIMEOUT) && info->bd_connected) {
        info->bd(CMD_EXIT, info->bd_info); // disconnect bus driver
        if (info->danfysik_settings.detailed_msg)
          cm_msg(MINFO, "danfysik_get", "Danfysik: try to disconnect and reconnect the bus driver");
        info->last_reconnect = ss_time();
        info->bd_connected = 0;
        if (info->danfysik_settings.ets_in_use)
          ets_logout(info->bd_info, DANFYSIK_ETS_LOGOUT_SLEEP, info->danfysik_settings.detailed_msg);
      }
    }
    return FE_SUCCESS;
  }

  // decode readback
  switch (channel) {
    case 0: // local or remote
      if (strstr(str_clean, "LOC"))
        *pvalue = 0.f;
      else if (strstr(str_clean, "REM"))
        *pvalue = 1.f;
      else
        *pvalue = (float) DANFYSIK_READ_ERROR;
      info->danfysik_remote = *pvalue;
      break;
    case 1: // read set value
      sscanf(str_clean, "%d", &value);
      // read polarity
      strcpy(cmd, "PO\r");
      BD_PUTS(cmd);
      status = BD_GETS(str, sizeof(str), "\r", DANFYSIK_TIME_OUT);
      danfysik_strip_rubbish(str, str_clean);
      if (strstr(str_clean, "+"))
        *pvalue = (float)value/1.0e3;
      else
        *pvalue = -1.0*(float)value/1.0e3;
      break;
    case 2: // read output voltage
      sscanf(str_clean, "%d", &value);
      *pvalue = (float)value/1.0e2;
      break;
    case 3: // read output current
      sscanf(str_clean, "%d", &value);
      *pvalue = (float)value/1.0e3;
      break;
    case 4: // read status
      sscanf(str_clean, "%d", &value);
      *pvalue = (float)value;
      break;
    default:
      *pvalue = (float) DANFYSIK_READ_ERROR;
      return FE_SUCCESS;
  }
  info->last_valid_value[channel] = *pvalue; // keep the last valid value
  info->empty_readback_error = 0;            // reset empty readback error counter
  info->readback_failure     = 0;            // reset readback failure error counter

  // read and decode status at each cycle
  memset(str, 0, sizeof(str));
  BD_PUTS("S1H\r");
  status = BD_GETS(str, sizeof(str), "\r", DANFYSIK_TIME_OUT);
  danfysik_strip_rubbish(str, str_clean);
  if (danfysik_error_read(4, str_clean)) {
    return FE_SUCCESS;
  } else {
    danfysik_decode_status(info, str_clean);
  }
     
  return FE_SUCCESS;
}

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

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

    case CMD_GET:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue  = va_arg(argptr, float*);
      status = danfysik_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  = danfysik_in_get_label(info, channel, name);
      break;

    default:
      break;
    }

  va_end(argptr);

  return status;
}
/*------------------------------------------------------------------*/
INT danfysik_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 = danfysik_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  = danfysik_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 = danfysik_set(info, channel, value);
      break;

    default:
      break;
    }

  va_end(argptr);

  return status;
}
/*------------------------------------------------------------------*/