hv_nhq_20xm_mscb.c

Go to the documentation of this file.

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

  Name:         hv_nhq_20xm_mscb.c
  Created by:   Andreas Suter, 2005/09/05

  Contents:     iseg NHQ 20xM High Voltage Device Driver

  RS232:        9600 baud, 8 data bits, 1 stop bit, no parity bit,
                protocol: none, termination: "\r\n"

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

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

#define NHQ_MAX_INIT_LOOP 5 

#define NHQ_DEBUG 0   

#define NHQ_ON  0x000 
#define NHQ_OFF 0x001 
#define NHQ_MAN 0x002 
#define NHQ_ERR 0x004 
#define NHQ_INH 0x008 
#define NHQ_QUA 0x010 
#define NHQ_TRP 0x020 

//--- NHQ status flags ---------------------------------------------
#define NHQ_CH_MAN      0x02 
#define NHQ_POL_POS     0x04 
#define NHQ_CH_OFF      0x08 
#define NHQ_KILL_ENABLE 0x10 
#define NHQ_CH_INHIBIT  0x20 
#define NHQ_TOO_HIGH    0x40 
#define NHQ_BAD_QUAL    0x80 

#define NHQ_NO_CHS   2

#define NHQ_NO_VARS  29

//---- NHQ commands ------------------------------------------------
#define NHQ_CMD      0x01 
#define NHQ_CMD_D    0x02 
#define NHQ_CMD_V    0x04 
#define NHQ_ID       0x06 
#define NHQ_WAITTIME 0x07 
#define NHQ_U        0x08 
#define NHQ_I        0x0A 
#define NHQ_M        0x0C 
#define NHQ_N        0x0E 
#define NHQ_D        0x10 
#define NHQ_V        0x12 
#define NHQ_L        0x14 
#define NHQ_S        0x16 
#define NHQ_T        0x18 
#define NHQ_A        0x1A 
#define NHQ_BAUD     0x1C 

#define NHQ_MAX_ALLOWED_ERR 25

//---- globals -----------------------------------------------------

typedef struct {
  BOOL  enabled;                      
  BOOL  debug;                        
  char  port[NAME_LENGTH];            
  char  pwd[NAME_LENGTH];             
  INT   group_addr;                   
  INT   node_addr;                    
  char  reboot_time[NAME_LENGTH];     
  int   odb_offset;                   
  char  device_name[NAME_LENGTH];     
  float max_voltage;                  
  float max_current;                  
  char  ch_names[NHQ_NO_CHS][NAME_LENGTH]; 
  float update_threshold_measured[NHQ_NO_CHS]; 
  float update_threshold_current[NHQ_NO_CHS];  
  float voltage_limit[NHQ_NO_CHS];    
  float current_limit[NHQ_NO_CHS];    
  float ramp_speed_up[NHQ_NO_CHS];    
  float ramp_speed_down[NHQ_NO_CHS];  
} HV_NHQ_20XM_SETTINGS;

#define HV_NHQ_20XM_SETTINGS_STR "\
Enabled = BOOL : 0\n\
Debug = BOOL : 0\n\
Device = STRING : [32] mscbfff \n\
PWD = STRING : [32] ???? \n\
Group Addr = INT : 1\n\
Node Addr = INT : 11\n\
Reboot Time = STRING : [32] 00:57\n\
ODB Offset = INT : 0\n\
Device Name = STRING : [32] NHQ 204M Trigger Module 1 \n\
Max. Voltage (kV) = FLOAT : 4.f \n\
Max. Current (mA) = FLOAT : 3.f \n\
CH_Name = STRING[2] : \n\
[32] NHQ 204M%A \n\
[32] NHQ 204M%B \n\
Update Threshold Measured = FLOAT[2] : \n\
0.005 \n\
0.005 \n\
Update Threshold Current  = FLOAT[2] : \n\
0.005 \n\
0.005 \n\
Voltage Limit = FLOAT[2] : \n\
4.0 \n\
4.0 \n\
Current Limit = FLOAT[2] : \n\
0.001 \n\
0.001 \n\
Ramp Speed Up = FLOAT[2] : \n\
0.1 \n\
0.1 \n\
Ramp Speed Down = FLOAT[2] : \n\
0.0 \n\
0.0 \n\
"

typedef struct {
  char  id[32];    
  int   wait_time; 
  float u[2];      
  float i[2];      
  int   m[2];      
  int   n[2];      
  float d[2];      
  float v[2];      
  int   l[2];      
  char  s[2][8];   
  int   t[2];      
  int   a[2];      
} MSCB_NODE_VARS;

typedef struct {
  HV_NHQ_20XM_SETTINGS settings; 
  MSCB_NODE_VARS data;           
  int   reboot_time[2];          
  int   fd;                      
  int   ch_status[NHQ_NO_CHS];   
  int   ch_pol[NHQ_NO_CHS];      
  int   num_channels;            
  HNDLE hDB;                     
  HNDLE dd_hkey;                 
  INT   startup_error;           
  DWORD timer;                   
  int   rebooting;               
  int   err;                     
} HV_NHQ_20XM_INFO;


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

//----------------------------------------------------------------------------
int hv_nhq_20xm_mscb_get_all(HV_NHQ_20XM_INFO *info, BOOL read_all)
{
  int status;
  int i;
  unsigned char buffer[256];
  int size = sizeof(buffer);
  int value;
  float fvalue, fexp;
  
  FILE *fp;

  if (read_all) { // only needed at startup
    // read id
    size = 32*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_ID, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    strncpy(info->data.id, (const char *)buffer, 32);
    
    // read wait time
    size = 6*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_WAITTIME, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    status = sscanf((const char *)buffer, "%d", &value);
    if (status != 1) // error
      return -1;
    info->data.wait_time = value;
    
    for (i=0; i<NHQ_NO_CHS; i++) {
      // read HV limit
      size = 6*sizeof(char);
      status = mscb_read(info->fd, info->settings.node_addr, NHQ_M+i, buffer, &size);
      if (status != MSCB_SUCCESS) { // not successfull
        info->err++;
        return status;
      }
      status = sscanf((const char *)buffer, "%d", &value);
      if (status != 1) // error
        return -1;
      info->data.m[i] = value;
    
      // read current limit
      size = 6*sizeof(char);
      status = mscb_read(info->fd, info->settings.node_addr, NHQ_N+i, buffer, &size);
      if (status != MSCB_SUCCESS) { // not successfull
        info->err++;
        return status;
      }
      status = sscanf((const char *)buffer, "%d", &value);
      if (status != 1) // error
        return -1;
      info->data.n[i] = value;
    
      // read ramping speed
      size = 6*sizeof(char);
      status = mscb_read(info->fd, info->settings.node_addr, NHQ_V+i, buffer, &size);
      if (status != MSCB_SUCCESS) { // not successfull
        info->err++;
        return status;
      }
      status = sscanf((const char *)buffer, "%d", &value);
      if (status != 1) // error
        return -1;
      info->data.v[i] = (float)value/1.0e3; // V/s -> kV/s
    
      // read current trip level
      size = 6*sizeof(char);
      status = mscb_read(info->fd, info->settings.node_addr, NHQ_L+i, buffer, &size);
      if (status != MSCB_SUCCESS) { // not successfull
        info->err++;
        return status;
      }
      status = sscanf((const char *)buffer, "%d", &value);
      if (status != 1) // error
        return -1;
      info->data.l[i] = value;
    
      // read autostart tag
      size = 6*sizeof(char);
      status = mscb_read(info->fd, info->settings.node_addr, NHQ_A+i, buffer, &size);
      if (status != MSCB_SUCCESS) { // not successfull
        info->err++;
        return status;
      }
      status = sscanf((const char *)buffer, "%d", &value);
      if (status != 1) // error
        return -1;
      info->data.a[i] = value;
    }
  }

  for (i=0; i<NHQ_NO_CHS; i++) {
    
    ss_sleep(50);
    
    // read measured HV
    size = 6*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_U+i, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    status = sscanf((const char *)buffer, "%d", &value);
    if (status != 1) // error
      return -1;
    info->data.u[i] = (float)value/1.0e3; // V -> kV
    
    ss_sleep(50);
    
    // read demand HV
    size = 6*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_D+i, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    status = sscanf((const char *)buffer, "%d", &value);
    if (status != 1) // error
      return -1;
    info->data.d[i] = (float)value/1.0e3; // V -> kV
    
    ss_sleep(50);
    
    // read measured current
    size = 8*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_I+i, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    status = sscanf((const char *)buffer, "%f%f,", &fvalue, &fexp);
    if (status != 2) // error
      return -1;
    sprintf((char *)buffer, "%0.1fE%f", fvalue, fexp); // construct a 'float string'
    sscanf((const char *)buffer, "%f", &fvalue);              // extract float from 'float string'
    info->data.i[i] = fvalue*1.0e3; // A -> mA  
    
    ss_sleep(50);
    
    // read status
    size = 8*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_S+i, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    strncpy(info->data.s[i], (const char *)buffer, 8);
    
    ss_sleep(50);
    
    // read device status
    size = 6*sizeof(char);
    status = mscb_read(info->fd, info->settings.node_addr, NHQ_T+i, buffer, &size);
    if (status != MSCB_SUCCESS) { // not successfull
      info->err++;
      return status;
    }
    status = sscanf((const char *)buffer, "%d", &value);
    if (status != 1) // error
      return -1;
    info->data.t[i] = value;
  }
    
  info->err = 0;
  
  if (info->settings.debug) {
    fp = fopen("hv_nhq_20xm_mscb.log", "a");

    if (read_all) {
      fprintf(fp, "id:        %s\n", info->data.id);
      fprintf(fp, "wait_time: %d\n", info->data.wait_time);
      fprintf(fp, "u: %f, %f\n", info->data.u[0], info->data.u[1]);
      fprintf(fp, "i: %f, %f\n", info->data.i[0], info->data.i[1]);
      fprintf(fp, "m: %d, %d\n", info->data.m[0], info->data.m[1]);      
      fprintf(fp, "n: %d, %d\n", info->data.n[0], info->data.n[1]);
      fprintf(fp, "d: %f, %f\n", info->data.d[0], info->data.d[1]);
      fprintf(fp, "v: %f, %f\n", info->data.v[0], info->data.v[1]);
      fprintf(fp, "l: %d, %d\n", info->data.l[0], info->data.l[1]);
      fprintf(fp, "s: %s, %s\n", info->data.s[0], info->data.s[1]);
      fprintf(fp, "t: %d, %d\n", info->data.t[0], info->data.t[1]);
      fprintf(fp, "a: %d, %d\n", info->data.a[0], info->data.a[1]);
      fprintf(fp, "------------------------\n");
    } else {
      fprintf(fp, "u: %f, %f\n", info->data.u[0], info->data.u[1]);
      fprintf(fp, "i: %f, %f\n", info->data.i[0], info->data.i[1]);
      fprintf(fp, "d: %f, %f\n", info->data.d[0], info->data.d[1]);
      fprintf(fp, "s: %s, %s\n", info->data.s[0], info->data.s[1]);
      fprintf(fp, "t: %d, %d\n", info->data.t[0], info->data.t[1]);
      fprintf(fp, "------------------------\n");
    }

    fclose(fp);
  }

  return MSCB_SUCCESS;
}
 
//----------------------------------------------------------------------------
void hv_nhq_20xm_mscb_check_status(HV_NHQ_20XM_INFO *info, int ch)
{
  if (strstr(info->data.s[ch], "?")) { // synchronization error
    return;
  }
  if (strstr(info->data.s[ch], "ON")) {
    if (info->ch_status[ch] != NHQ_ON) {
      info->ch_status[ch]=NHQ_ON;
      cm_msg(MINFO, "hv_nhq_20xm_check_status", "%s, ch %s, channel switched on at the frontpanel. (%s)",
             info->settings.device_name, info->settings.ch_names[ch], info->data.s[ch]);
    }
  }
  if (strstr(info->data.s[ch], "OFF")) {
    if (!(info->ch_status[ch] & NHQ_OFF)) {
      info->ch_status[ch] |= NHQ_OFF;
      cm_msg(MERROR, "hv_nhq_20xm_check_status", "%s, ch %s, channel switched off at the frontpanel. (%s)",
             info->settings.device_name, info->settings.ch_names[ch], info->data.s[ch]);
    }
  } else if (strstr(info->data.s[ch], "MAN")) {
    if (!(info->ch_status[ch] & NHQ_MAN)) {
      info->ch_status[ch] |= NHQ_MAN;
      cm_msg(MERROR, "hv_nhq_20xm_check_status", "%s, ch %s, hv switched to manual.",
             info->settings.device_name, info->settings.ch_names[ch]);
    }
  } else if (strstr(info->data.s[ch], "ERR")) {
    if (!(info->ch_status[ch] & NHQ_ERR)) {
      info->ch_status[ch] |= NHQ_ERR;
      cm_msg(MERROR, "hv_nhq_20xm_check_status", "%s, ch %s, V_max or I_max exceeded.",
             info->settings.device_name, info->settings.ch_names[ch]);
    }
  } else if (strstr(info->data.s[ch], "INH")) {
    if (!(info->ch_status[ch] & NHQ_INH)) {
      info->ch_status[ch] |= NHQ_INH;
      cm_msg(MERROR, "hv_nhq_20xm_check_status", "%s, ch %s, inhibit signal was active.",
             info->settings.device_name, info->settings.ch_names[ch]);
    }
  } else if (strstr(info->data.s[ch], "QUA")) {
    if (!(info->ch_status[ch] & NHQ_QUA)) {
      info->ch_status[ch] |= NHQ_QUA;
      cm_msg(MERROR, "hv_nhq_20xm_check_status",
             "%s, ch %s, quality of output voltage not guaranteed at present.",
             info->settings.device_name, info->settings.ch_names[ch]);
    }
  } else if (strstr(info->data.s[ch], "TRP")) {
    if (!(info->ch_status[ch] & NHQ_TRP)) {
      info->ch_status[ch] |= NHQ_TRP;
      cm_msg(MERROR, "hv_nhq_20xm_check_status", "%s, ch %s, current trip was active.",
             info->settings.device_name, info->settings.ch_names[ch]);
    }
  }
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_update_odb(HV_NHQ_20XM_INFO *info, int channels)
{
  int   status, i;
  HNDLE hKey;
  int   offset = info->settings.odb_offset;
  float value;

  // Update Threshold Measured
  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Update Threshold Measured", &hKey);
  if (status != DB_SUCCESS)
    return status;
  for (i=0; i<channels; i++) {
    db_set_data_index(info->hDB, hKey, &info->settings.update_threshold_measured[i],
                      sizeof(float), i+offset, TID_FLOAT);
  }

  // Update Threshold Current
  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Update Threshold Current", &hKey);
  if (status != DB_SUCCESS)
    return status;
  for (i=0; i<channels; i++) {
    db_set_data_index(info->hDB, hKey, &info->settings.update_threshold_current[i],
                      sizeof(float), i+offset, TID_FLOAT);
  }

  // Voltage Limit
  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Voltage Limit", &hKey);
  if (status != DB_SUCCESS)
    return status;
  for (i=0; i<channels; i++) {
    db_set_data_index(info->hDB, hKey, &info->settings.voltage_limit[i],
                      sizeof(float), i+offset, TID_FLOAT);
  }

  // Current Limit
  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Current Limit", &hKey);
  if (status != DB_SUCCESS)
    return status;
  for (i=0; i<channels; i++) {
    db_set_data_index(info->hDB, hKey, &info->settings.current_limit[i],
                      sizeof(float), i+offset, TID_FLOAT);
  }

  // Ramp Up Speed
  value = 0.1; // ramping is done in the nhq itself, therefore the class driver ramping speed = 0.0
  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Ramp Up Speed", &hKey);
  if (status != DB_SUCCESS)
    return status;
  for (i=0; i<channels; i++) {
    db_set_data_index(info->hDB, hKey, &value, sizeof(float), i+offset, TID_FLOAT);
  }

  // Ramp Down Speed
  value = 0.0; // ramping is done in the nhq itself, therefore the class driver ramping speed = 0.0
  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Ramp Down Speed", &hKey);
  if (status != DB_SUCCESS)
    return status;
  for (i=0; i<channels; i++) {
    db_set_data_index(info->hDB, hKey, &value, sizeof(float), i+offset, TID_FLOAT);
  }

  return DB_SUCCESS;
}

//----------------------------------------------------------------------------
int hv_nhq_20xm_mscb_set_ramping(HV_NHQ_20XM_INFO *info, INT channels)
{
  int   status, i, size;
  HNDLE hKey;
  int   offset = info->settings.odb_offset;
  float value;
  char  cmd[16]; 

  status = db_find_key(info->hDB, 0, "/Equipment/HV Detectors/Settings/Ramp Up Speed", &hKey);
  if (status != DB_SUCCESS)
    return status;
 
  for (i=0; i<channels; i++) {
    size = sizeof(float);
    status = db_get_data_index(info->hDB, hKey, &value, &size, i+offset, TID_FLOAT); 
    if (status != DB_SUCCESS)
      break;
    size = sizeof(cmd);
    sprintf(cmd, "V%d=%03d", i+1, abs((int)(value*1.0e3)));
    status = mscb_write(info->fd, info->settings.node_addr, (unsigned char)NHQ_CMD_V+i, cmd, size);
  }
  
  return DB_SUCCESS;
}

//----------------------------------------------------------------------------
void hv_nhq_20xm_mscb_get_reboot_time(HV_NHQ_20XM_INFO *info)
{
  int status, hh, mm;

  // extract hour and min from the DD entry
  status = sscanf(info->settings.reboot_time, "%d:%d", &hh, &mm);

  // check for correctness
  if ((status == 2) && ((hh>=0) && (hh<=23)) && ((mm>=0) && (mm<=59))) { // correct
    info->reboot_time[0] = hh;
    info->reboot_time[1] = mm;
  } else { // not correct
    info->reboot_time[0] = -1;
    info->reboot_time[1] = -1;
  }
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  int   status, size, i;
  char  pol[16];
  HNDLE hDB, ddhKey;
  HV_NHQ_20XM_INFO *info;

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

  cm_get_experiment_database(&hDB, NULL);

  // create HV_NHQ_20XM device driver setting record
  status = db_create_record(hDB, hKey, "DD", HV_NHQ_20XM_SETTINGS_STR);
  if ((status != DB_SUCCESS) && (status != DB_OPEN_RECORD)) {
    cm_msg(MERROR, "hv_nhq_20xm_init", "hv_nhq_20xm_init: Error creating NHQ DD record in ODB, status=%d", status);
    cm_yield(0);
    return FE_ERR_ODB;
  }

  db_find_key(hDB, hKey, "DD", &ddhKey);

  size = sizeof(info->settings);
  db_get_record(hDB, ddhKey, &info->settings, &size, 0);
  
  // check if the device is enabled
  if (!info->settings.enabled) {
    cm_msg(MINFO, "hv_nhq_20xm_mscb_init", "\"%s\" is disabled from the ODB.", info->settings.device_name);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }

  // initialize driver settings
  info->num_channels   = channels;
  info->hDB            = hDB;
  info->dd_hkey        = ddhKey;
  info->startup_error  = FALSE;
  info->timer          = ss_millitime();
  info->rebooting      = 0;
  info->ch_status[0]   = NHQ_ON;
  info->ch_status[1]   = NHQ_ON;
  info->err            = 0;

  // get reboot time
  hv_nhq_20xm_mscb_get_reboot_time(info);

  // update ODB HV settings
  status = hv_nhq_20xm_mscb_update_odb(info, channels);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "hv_nhq_20xm_mscb_update_odb", "Error by updating ODB HV settings.");
    cm_yield(0);
  }

  cm_msg(MINFO, "hv_nhq_20xm_mscb_init","initialize %s.", info->settings.device_name);
  cm_yield(0);

  // init mscb
  info->fd = mscb_init(info->settings.port, sizeof(info->settings.port), info->settings.pwd, NHQ_DEBUG);
  if (info->fd < 0) {
    cm_msg(MINFO, "hv_nhq_20xm_mscb_init", "hv_nhq_20xm_mscb_init: Couldn't initialize %s, MSCB device %s",
           info->settings.device_name, info->settings.port);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }
  cm_msg(MINFO, "hv_nhq_20xm_mscb_init", "hv_nhq_20xm_mscb_init: %s, MSCB node %d initialized.",
         info->settings.device_name, info->settings.node_addr);
  cm_yield(0);

  // set ramping speed       
  hv_nhq_20xm_mscb_set_ramping(info, channels);
         
  // read variables
  for (i=0; i<NHQ_MAX_INIT_LOOP; i++) {
    status = hv_nhq_20xm_mscb_get_all(info, TRUE);
    if (status == MSCB_SUCCESS)
      break;
    ss_sleep(500);
  }
  
  if (status != MSCB_SUCCESS) {
    cm_msg(MINFO, "hv_nhq_20xm_mscb_init", "hv_nhq_20xm_mscb_init: %s, Couldn't read data.",
           info->settings.device_name);
    cm_yield(0);
    info->startup_error = 1;
    return FE_SUCCESS;
  }

  // report id
  cm_msg(MINFO, "hv_nhq_20xm_mscb_init", "hv_nhq_20xm_mscb_init: %s, node %d, id=%s",
         info->settings.device_name, info->settings.node_addr, info->data.id);

  // report wait time
  cm_msg(MINFO, "hv_nhq_20xm_mscb_init", "hv_nhq_20xm_mscb_init: %s, node %d, wait time=%d (ms)",
         info->settings.device_name, info->settings.node_addr, info->data.wait_time);

  // report hv limits
  for (i=0; i<NHQ_NO_CHS; i++) {
    cm_msg(MINFO, "hv_nhq_20xm_init", "%s: channel %d - hardware voltage limit = %d%% of %f (kV)",
         info->settings.device_name, i+1, info->data.m[i], info->settings.max_voltage);
  }

  // report current limits
  for (i=0; i<NHQ_NO_CHS; i++) {
    cm_msg(MINFO, "hv_nhq_20xm_init", "%s: channel %d - hardware current limit = %d%% of %f (mA)",
           info->settings.device_name, i+1, info->data.n[i], info->settings.max_current);
  }

  // report status infos
  for (i=0; i<NHQ_NO_CHS; i++) {
    cm_msg(MINFO, "hv_nhq_20xm_init", "%s: status info channel %d: %s",
           info->settings.device_name, i+1, info->data.s[i]);
  }

  // report polarities
  for (i=0; i<NHQ_NO_CHS; i++) {
    if (info->data.t[i] & NHQ_POL_POS) { // positive polarity
      info->ch_pol[i] = 1;
      strcpy(pol, "positive");
    } else { // negative polarity
      info->ch_pol[i] = -1;
      strcpy(pol, "negative");
    }
    cm_msg(MINFO, "hv_nhq_20xm_init", "%s: channel %s - pol = %s",
           info->settings.device_name, info->settings.ch_names[i], pol);
  }
  cm_yield(0);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_exit(HV_NHQ_20XM_INFO *info)
{
  if (info->startup_error) return FE_SUCCESS;

  // call EXIT function of the mscb lib
  mscb_exit(info->fd);

  free(info);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_set(HV_NHQ_20XM_INFO *info, INT channel, float value)
{
  int   status, size;
  char  cmd[16];

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

  // check if demand hv setting is within allowed limits
  if (value > info->settings.voltage_limit[channel]) {
    cm_msg(MERROR, "hv_nhq_20xm_mscb_set", "%s: %s set value = %f exceeds voltage limit = %f.",
           info->settings.device_name, info->settings.ch_names[channel], value,
           info->settings.voltage_limit[channel]);
    return FE_SUCCESS;
  }

  // set new voltage
  size = sizeof(cmd);
  sprintf(cmd, "D%d=%04d", channel+1, abs((int)(value*1.0e3)));
  status = mscb_write(info->fd, info->settings.node_addr, (unsigned char)NHQ_CMD_D+channel, cmd, size);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_get_label(HV_NHQ_20XM_INFO *info, INT channel, char *name)
{
  strcpy(name, info->settings.ch_names[channel]);

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_get(HV_NHQ_20XM_INFO *info, INT channel, float *pvalue)
{
  time_t tt;
  struct tm now;
  int status;

  // check if there have been any startup errors
  if (info->startup_error) {
    *pvalue = -999.;
    ss_sleep(10); // to keep CPU load low when Run active
    return FE_SUCCESS;
  }

  // check if a reboot time is set and if yes, if it is reached
  if ((info->reboot_time[0] != -1) && !info->rebooting) {
    time(&tt);
    localtime_r(&tt, &now);
    if ((now.tm_hour == info->reboot_time[0]) && (now.tm_min == info->reboot_time[1])) {
      // reboot
      mscb_reboot(info->fd, info->settings.node_addr, info->settings.group_addr, 0);
      // prevent reading data for a while
      info->timer = ss_millitime() + 60000;  // shift timer 60 sec into the future
      // tell the system that a reboot is taking place
      info->rebooting = 1;
    }
  }

  // just after a reboot, do nothing 
  // (necessary since if info->timer > ss_millitime(), i.e. ss_millitime() - info->timer < 0
  //  there is a problem, since DWORD will see negative times as positive ones!)
  if (info->timer > ss_millitime())
    return FE_SUCCESS;
  
  
  if ((ss_millitime() - info->timer) > 5000) { // read data from nhq
    // reset rebooting flag
    info->rebooting = 0;
    info->timer = ss_millitime(); // restart timer
    status = hv_nhq_20xm_mscb_get_all(info, FALSE);
    if (status != MSCB_SUCCESS)
      return FE_SUCCESS;
  }
  
  ss_sleep(10); // in order to keep the frontend CPU load low

  hv_nhq_20xm_mscb_check_status(info, channel); // check status

  *pvalue = info->data.u[channel];

  if (info->err == NHQ_MAX_ALLOWED_ERR) {
    cm_msg(MERROR, "hv_nhq_20xm_mscb_get",
           "hv_nhq_20xm_mscb_get: Too many read back errors. Probably a communication problem.");
  }

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_get_demand(HV_NHQ_20XM_INFO *info, INT channel, float *pvalue)
{
  // check if there have been any startup errors
  if (info->startup_error) {
    *pvalue = -999.f;
    ss_sleep(10); // to keep CPU load low when Run active
    return FE_SUCCESS;
  }

  // return demand HV
  *pvalue = info->data.d[channel];

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb_get_current(HV_NHQ_20XM_INFO *info, INT channel, float *pvalue)
{

  // check if there have been any startup errors
  if (info->startup_error) {
    *pvalue = -999.f;
    ss_sleep(10); // to keep CPU load low when Run active
    return FE_SUCCESS;
  }

  if (info->data.i[channel]<1.0)
    *pvalue = info->data.i[channel];

  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
//---- device driver entry point ---------------------------------------------
//----------------------------------------------------------------------------
INT hv_nhq_20xm_mscb(INT cmd, ...)
{
va_list argptr;
HNDLE   hKey;
INT     channel, status;
float   value, *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 = hv_nhq_20xm_mscb_init(hKey, info, channel, bd);
      break;

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

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

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

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

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

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

    
    // this are known commands of the class driver but not implmented yet or not needed
    case CMD_SET_TRIP_TIME:
    case CMD_SET_CURRENT_LIMIT:
    case CMD_SET_RAMPUP:
    case CMD_SET_RAMPDOWN:
    case CMD_SET_VOLTAGE_LIMIT:
    case CMD_GET_VOLTAGE_LIMIT:
    case CMD_SET_LABEL:
    case CMD_GET_THRESHOLD:
    case CMD_GET_THRESHOLD_CURRENT:
    case CMD_GET_CURRENT_LIMIT:
    case CMD_GET_TRIP_TIME:
    case CMD_GET_RAMPUP:
    case CMD_GET_RAMPDOWN:
    case CMD_STOP:
      break;

    default:
      break;
    }

  va_end(argptr);

  return status;
}

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