hvr400.c

Go to the documentation of this file.

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

  Name:         hvr400.c
  Created by:   Andreas Suter  2005/06/27

  Contents:     MIDAS device driver declaration for the MSCB high voltage
                dividers hvr_400.

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

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

#include "hvr400.h"

#include "lemSCWatchdog.h"

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

#define HVR400_INIT_ERROR -2   

#define HVR400_MAX_ERROR        5   
#define HVR400_DELTA_TIME_ERROR 600 

// ----------- HVR400 related infos ---------------------------------
#define MSCB_DEBUG FALSE

// HVR400 offsets ---------------------------------------------------
#define HVR400_CONTROL   0
#define HVR400_VDEMAND   1
#define HVR400_VMEAS     2
#define HVR400_IMEAS     3
#define HVR400_STATUS    4
#define HVR400_TRIPCNT   5
#define HVR400_RAMPUP    6
#define HVR400_RAMPDOWN  7
#define HVR400_VLIMIT    8
#define HVR400_ILIMIT    9
#define HVR400_RILIMIT  10
#define HVR400_TRIPMAX  11
#define HVR400_TRIPTIME 12

// HVR400 Control Bits ----------------------------------------------
#define HVR400_CTRL_HV_ON       0x01
#define HVR400_CTRL_REGULATION  0x02
#define HVR400_CTRL_IDLE        0x04

typedef struct {
  BOOL enabled;                        
  BOOL scw_in_use;                     
  INT  detailed_msg;                   
  char port[NAME_LENGTH];              
  char pwd[NAME_LENGTH];               
  INT  group_addr;                     
  INT  node_addr;                      
  char name[NAME_LENGTH];              
  INT  odb_offset;                     
} HVR400_SETTINGS;

#define HVR400_SETTINGS_STR "\
Enabled = BOOL : 0\n\
SCW_IN_USE = BOOL : 0\n\
Detailed Messages = INT : 0\n\
MSCB Port = STRING : [32] usb1\n\
MSCB Pwd = STRING : [32]\n\
Group Addr = INT : 400\n\
Node Addr = INT : 1\n\
HVR400 Name = STRING : [32] HVR400_1\n\
HV ODB Offset = INT : 0\n\
"

//------------------------------------------------------------------
typedef struct {
   unsigned char control;   
   float u_demand;          
   float u_meas;            
   float i_meas;            
   unsigned char status;    
   unsigned char trip_cnt;  

   float ramp_up;           
   float ramp_down;         
   float u_limit;           
   float i_limit;           
   float ri_limit;          
   unsigned char trip_max;  
   unsigned char trip_time; 

   unsigned char cached;    
} HVR400_NODE_VARS;


#define HVR400_SCW_STR "\
Proc Name = STRING : [32]\n\
PID = INT : -1\n\
Log Name = STRING : [64]\n\
DD Name = STRING : [32] \n\
Last Updated = DWORD : 0\n\
Timeout = DWORD : 180\n\
"

typedef struct {
  HVR400_SETTINGS settings;           
  HVR400_NODE_VARS *node_vars;        
  LEM_SC_WATCHDOG scw;                
  INT   fd;                           
  INT   errcount;                     
  INT   startup_error;                
  DWORD lasterrtime;                  
} HVR400_INFO;


// device driver support routines -------------------------------------------------
INT hvr400_read_all(HVR400_INFO* info, int channel)
{
   int size, status;
   unsigned char buffer[256], *pbuf;

   size = sizeof(buffer);
   status = mscb_read_range(info->fd, info->settings.node_addr+channel, 0, 12, buffer, &size);
   if (status != MSCB_SUCCESS) {
      cm_msg(MERROR, "hr400_read_all",
            "Cannot access MSCB HVR400 address \"%d\". Check power and connection.", 
            info->settings.node_addr);
      return FE_ERR_HW;
   }

   /* decode variables from buffer */
   pbuf = buffer;
   info->node_vars[channel].control = *((unsigned char *)pbuf);
   pbuf += sizeof(char);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].u_demand = *((float *)pbuf);
   pbuf += sizeof(float);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].u_meas = *((float *)pbuf);
   pbuf += sizeof(float);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].i_meas = *((float *)pbuf);
   pbuf += sizeof(float);
   info->node_vars[channel].status = *((unsigned char *)pbuf);
   pbuf += sizeof(char);
   info->node_vars[channel].trip_cnt = *((unsigned char *)pbuf);
   pbuf += sizeof(char);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].ramp_up = *((float *)pbuf);
   pbuf += sizeof(float);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].ramp_down = *((float *)pbuf);
   pbuf += sizeof(float);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].u_limit = *((float *)pbuf);
   pbuf += sizeof(float);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].i_limit = *((float *)pbuf);
   pbuf += sizeof(float);
   DWORD_SWAP(pbuf);
   info->node_vars[channel].ri_limit = *((float *)pbuf);
   pbuf += sizeof(float);
   info->node_vars[channel].trip_max = *((unsigned char *)pbuf);
   pbuf += sizeof(char);
   info->node_vars[channel].trip_time = *((unsigned char *)pbuf);

   /* mark voltage/current as valid in cache */
   info->node_vars[channel].cached = 1;

   return FE_SUCCESS;
}

//---- device driver routines --------------------------------------
INT hvr400_init(HNDLE hKey, void **pinfo, INT channels)
{
INT            status, size;
INT            i;
HNDLE          hDB, hkeydd;
MSCB_INFO      node_info;
HVR400_INFO   *info;

  // allocate info structure
  info = (HVR400_INFO *) calloc(1, sizeof(HVR400_INFO));
  info->node_vars = (HVR400_NODE_VARS *) calloc(channels, sizeof(HVR400_NODE_VARS));
  *pinfo = info;

  cm_get_experiment_database(&hDB, NULL);

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

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

  // create HVR400 slowcontrol watchdog DD settings
  status = db_create_record(hDB, hKey, "DD/SCW", HVR400_SCW_STR);
  if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
    cm_msg(MERROR, "hvr400_init", "hvr400_init: Error creating DD/SCW record in ODB, status=%d", status);
    cm_yield(0);
    return FE_ERR_ODB;
  }

  // initialize driver
  info->errcount      = 0;
  info->startup_error = 0;
  info->lasterrtime   = ss_time();

  if (!info->settings.enabled) {
    cm_msg(MINFO, "hvr400_init", "hvr400_init: %s not enabled", info->settings.name);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }

  // initialize MSCB
  info->fd = mscb_init(info->settings.port, sizeof(info->settings.port), info->settings.pwd, MSCB_DEBUG);
  if (info->fd < 0) {
    cm_msg(MINFO, "hvr400_init", "hvr400_init: Couldn't initialize MSCB port %s, Error no: %d",
           info->settings.port, info->fd);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }

  // check first node
  status = mscb_info(info->fd, info->settings.node_addr, &node_info);
  if (status != MSCB_SUCCESS) {
    cm_msg(MINFO, "hvr400_init", "Cannot access HVR node at address \"%d\". Please check cabling and power.", 
                                 info->settings.node_addr);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }
  
  // check if it is a HVR400
  if (strcmp(node_info.node_name, "HVR-400") != 0) {
    cm_msg(MINFO, "hvr400_init",
           "Found unexpected node \"%s\" at address \"%d\".", 
           node_info.node_name, info->settings.node_addr);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }
    
  // read all values from the HVR400 devices
  for (i=0; i<channels; i++) {
    status = hvr400_read_all(info, i);
    if (status != FE_SUCCESS) {
      info->startup_error = 1;
      return FE_SUCCESS;
    }
  }
  
  cm_msg(MINFO, "hvr400_init", "hvr400_init: %s initialized", info->settings.name);
  cm_yield(0);

  if (info->settings.scw_in_use) { // slowcontrol watchdog shall be used
    // register with the slowcontrol watchdog -------------------------------------
    // find scw record in DD
    db_find_key(hDB, hKey, "DD/SCW", &hkeydd);
    // get record
    size = sizeof(info->scw);
    db_get_record(hDB, hkeydd, &info->scw, &size, 0);
    // fill watchdog structure
    info->scw.pid = ss_getpid();
    info->scw.last_updated = ss_time();
    strncpy(info->scw.name, info->settings.name, sizeof(info->scw.name));
    // write info back into ODB
    db_set_record(hDB, hkeydd, &info->scw, sizeof(info->scw), 0);

    // register with slowcontrol watchdog
    status = lem_scw_init(&info->scw);
    if (status != LEM_SCW_SUCCESS) {
      cm_msg(MINFO, "hvr400_init", "Couldn't register with lem watchdog");
      cm_yield(0);
    }
  }

  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT hvr400_exit(HVR400_INFO *info)
{
  // call EXIT function of MSCB driver, usually closes device
  if (!info->startup_error)
  mscb_exit(info->fd);

  if (info->settings.scw_in_use && !info->startup_error) { // slowcontrol watchdog in use
    // deregister from the slowcontrol watchdog
    lem_scw_exit(&info->scw);
  }

  free(info->node_vars);
  free(info);
  
  return FE_SUCCESS;
}

/*----------------------------------------------------------------------------*/
INT hvr400_set(HVR400_INFO *info, INT channel, float value)
{
  INT   status;
  unsigned char hv_on_off;
  float mscb_value;

  if ( info->startup_error ) {
    ss_sleep(10);
    return FE_SUCCESS;
  }

  // set HV value
  mscb_value = fabs(value*1000.f); // kV -> V
  status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel), 
                    (unsigned char) HVR400_VDEMAND, &mscb_value, 4);

  // check if it is necessay to switch HV on/off
  if (value == 0.0) { // demand HV==0 -> switch HV off
    if ((info->node_vars[channel].control & HVR400_CTRL_HV_ON) != 0) { // HV still on, hence switch it off
      hv_on_off = HVR400_CTRL_REGULATION;
      status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel),
                       (unsigned char) HVR400_CONTROL, &hv_on_off, 1);
    }
  } else {
    if ((info->node_vars[channel].control & HVR400_CTRL_HV_ON) == 0) { // HV has been off so far, hence switch it on
      hv_on_off = HVR400_CTRL_HV_ON | HVR400_CTRL_REGULATION;
      status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel),
                       (unsigned char) HVR400_CONTROL, &hv_on_off, 1);
    }
  }

  return FE_SUCCESS;
}

/*-----------------------------------------------------------------------------*/
INT hvr400_get(HVR400_INFO *info, INT channel, float *pvalue)
{
INT    status, size;
DWORD  nowtime, difftime;
unsigned char buffer[256], *pbuf;

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

  // check if there was a startup error
  if ( info->startup_error ) {
     *pvalue = (float) HVR400_INIT_ERROR;
     ss_sleep(10); // to keep CPU load low when Run active
     return FE_SUCCESS;
  }

  // check if the value was previously read by hvr400_read_all
  if (info->node_vars[channel].cached) {
    *pvalue = info->node_vars[channel].u_meas / 1000.f;
    info->node_vars[channel].cached = 0;
    return FE_SUCCESS;
  }
  
  // read voltage and current at the same time
  size = sizeof(buffer);
  status = mscb_read_range(info->fd, info->settings.node_addr+channel, HVR400_CONTROL, HVR400_IMEAS, buffer, &size);
  if (status != MSCB_SUCCESS) {
    info->errcount++;
    if (info->errcount < HVR400_MAX_ERROR) {
      cm_msg(MINFO, "hvr400_get", 
             "Cannot access MSCB HVR address \"%d\". Check power and connection.", 
             info->settings.node_addr+channel);
      return FE_SUCCESS;      
    }
  }
  
  // decode variables from buffer
  pbuf = buffer;
  info->node_vars[channel].control = *((unsigned char *)pbuf);  // 0
  pbuf += sizeof(char);
  DWORD_SWAP(pbuf);
  info->node_vars[channel].u_demand = *((float *)pbuf);         // 1
  pbuf += sizeof(float);
  DWORD_SWAP(pbuf);
  info->node_vars[channel].u_meas = *((float *)pbuf);            // 2
  pbuf += sizeof(float);
  DWORD_SWAP(pbuf);
  info->node_vars[channel].i_meas = *((float *)pbuf);            // 3

  *pvalue = info->node_vars[channel].u_meas / 1000.f;

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

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hvr400_set_current_limit(HVR400_INFO *info, INT channel, float limit)
{
  INT   status;
  DWORD nowtime, difftime;
  float mscb_value;

  if ( info->startup_error ) {
    ss_sleep(10);
    return FE_SUCCESS;
  }

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

  // set current limit value
  mscb_value = limit*1000.f; // mA -> uA
  status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel), 
                    (unsigned char) HVR400_ILIMIT, &mscb_value, 4);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hvr400_set_voltage_limit(HVR400_INFO *info, INT channel, float limit)
{
  INT   status;
  DWORD nowtime, difftime;
  float mscb_value;

  if ( info->startup_error ) {
    ss_sleep(10);
    return FE_SUCCESS;
  }

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

  // set voltage limit value
  mscb_value = limit*1000.f; // kV -> V
  status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel), 
                    (unsigned char) HVR400_VLIMIT, &mscb_value, 4);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hvr400_set_rampup(HVR400_INFO *info, INT channel, float ramp)
{
  INT   status;
  DWORD nowtime, difftime;
  float mscb_value;

  if ( info->startup_error ) {
    ss_sleep(10);
    return FE_SUCCESS;
  }

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

  // set ramp up value
  mscb_value = ramp * 1000.f; // kV/s -> V/s
  status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel), 
                    (unsigned char) HVR400_RAMPUP, &mscb_value, 4);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hvr400_set_rampdown(HVR400_INFO *info, INT channel, float ramp)
{
  INT   status;
  DWORD nowtime, difftime;
  float mscb_value;

  if ( info->startup_error ) {
    ss_sleep(10);
    return FE_SUCCESS;
  }

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

  // set ramp down value
  mscb_value = ramp * 1000.f; // kV/s -> V/s
  status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel), 
                    (unsigned char) HVR400_RAMPDOWN, &mscb_value, 4);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hvr400_set_triptime(HVR400_INFO *info, INT channel, float trip_time)
{
  INT   status;
  DWORD nowtime, difftime;
  unsigned char mscb_value;

  if ( info->startup_error ) {
    ss_sleep(10);
    return FE_SUCCESS;
  }

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

  // set trip time value
  mscb_value = (unsigned char) trip_time;
  status=mscb_write(info->fd, (unsigned short) (info->settings.node_addr+channel), 
                    (unsigned char) HVR400_TRIPTIME, &mscb_value, 1);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
//---- device driver entry point ---------------------------------------------
//----------------------------------------------------------------------------
INT hvr400(INT cmd, ...)
{
va_list argptr;
HNDLE   hKey;
INT     channel, status;
float   value, *pvalue;
HVR400_INFO *info;

  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);
      status = hvr400_init(hKey, (void **)info, channel);
      break;

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

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

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

    case CMD_GET_DEMAND:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = info->node_vars[channel].u_demand / 1000.f; // V -> kV
      break;

    case CMD_GET_CURRENT:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = info->node_vars[channel].i_meas / 1000.f; // uA -> mA
      break;

    case CMD_GET_LABEL:
      break;

    case CMD_SET_LABEL:
      break;

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

    case CMD_SET_VOLTAGE_LIMIT:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      value = (float) va_arg(argptr, double);
      status = hvr400_set_voltage_limit(info, channel, value);    
      break;
      
    case CMD_GET_VOLTAGE_LIMIT:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float *);
      *pvalue = info->node_vars[channel].u_limit / 1000.f; // V -> kV
      break;
    
    case CMD_GET_THRESHOLD:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = 0.1f;
      break;
      
    case CMD_GET_THRESHOLD_CURRENT:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = 0.001f;
      break;
      
    case CMD_GET_THRESHOLD_ZERO:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = 0.02f;
      break;
      
    case CMD_GET_CURRENT_LIMIT:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = info->node_vars[channel].i_limit / 1000.f; // uA -> mA 
      break;    
    
    case CMD_SET_RAMPUP:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      value = (float) va_arg(argptr, double);
      hvr400_set_rampup(info, channel, value);
      break;    
    
    case CMD_SET_RAMPDOWN:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      value = (float) va_arg(argptr, double);
      hvr400_set_rampdown(info, channel, value);
      break;    
    
    case CMD_GET_RAMPUP:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = info->node_vars[channel].ramp_up;
      break;    
    
    case CMD_GET_RAMPDOWN:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = info->node_vars[channel].ramp_down;
      break;    
        
    case CMD_SET_TRIP_TIME:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      value = (float) va_arg(argptr, double);
      hvr400_set_triptime(info, channel, value);
      break;    
    
    case CMD_GET_TRIP_TIME:
      info = va_arg(argptr, void *);
      channel = va_arg(argptr, INT);
      pvalue = va_arg(argptr, float*);
      *pvalue = info->node_vars[channel].trip_time;
      break;    
        
    case CMD_STOP:
      status = FE_SUCCESS;
      break;

    default:
      cm_msg(MERROR, "hvr400 device driver", "Received unkown command %d", cmd);
      status = FE_ERR_DRIVER;
      break;
  }

  va_end(argptr);

  return status;
}

//----------------------------------------------------------------------------
// end -----------------------------------------------------------------------
//----------------------------------------------------------------------------