ps64.c

Go to the documentation of this file.

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

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

  Contents:     ps64 vacuum controller; ps64 is the pumping station of
                the QSM610-612

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

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

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

// channels of the SPS input variables
#define PS64_LIFESIGN 0
#define PS64_GP       1
#define PS64_GS64     2
#define PS64_SW1      3
#define PS64_SW2      4

#define SPS_MAX_BYTES 680         
#define PS64_TIME_CONST    0    
#define PS64_TIMEOUT_ERROR 3600 

typedef struct {
  INT detailed_msg; 
} PS64_INTERN;

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

typedef struct {
char in_name[PS64_IN_VARS][NAME_LENGTH];   
char out_name[NAME_LENGTH];
} PS64_NAMES;

#define PS64_NAMES_STR "\
Input Names = STRING[5] : \n\
[32] PS64 Life Sign\n\
[32] PS64 GP Pirani\n\
[32] PS64 GS64\n\
[32] PS64 Status Word 1\n\
[32] PS64 Status Word 2\n\
Output Names = STRING : [32] PS64 Cmd\n\
"

typedef struct {
  PS64_INTERN intern;        
  PS64_NAMES ps64_names;   
  char ps64_buffer[SPS_MAX_BYTES]; 
  int  ps64_diag[6];         
  float ps64_data[PS64_IN_VARS];  
  INT (*bd)(INT cmd, ...);     
  void *bd_info;               
  HNDLE hDB;                   
  HNDLE hKey_in;               
  HNDLE hKey_out;              
  HNDLE hKey_DB_Buffer;        
  DWORD time;                  
  DWORD errTime;               
  INT   startup_error;         
  INT   tcpip_open_error;      
  INT   read_error;            
  INT   read_counts;           
  DWORD last_success;          
} PS64_INFO;

PS64_INFO *gInfo; 

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

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

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

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

  return val;
}

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

/*----------------------------------------------------------------------------*/
double ps64_pkr251(int analog)
{
  return pow(10.0, 1.667 * (double)analog/100.0 - 11.33);
}

/*----------------------------------------------------------------------------*/
double ps64_pirani_tpr280(int analog)
{
  return pow(10.0, (double)analog/100.0 - 5.5);
}


//----------------------------------------------------------------------------
BOOL ps64_decode_data(PS64_INFO *info, const char *buffer)
{
//int value;
static int count=0;

  if ((buffer[4] != 65) || (buffer[5] != 66)) // check if buffer has the right 'AB' signature
    return FALSE;

  info->ps64_data[PS64_LIFESIGN] = spsToNumber((unsigned char*)&buffer[10]); // lifesign counter
  info->ps64_data[PS64_GP] = ps64_pirani_tpr280(spsToNumber((unsigned char*)&buffer[368])); // PS64 Pirani
  info->ps64_data[PS64_GS64] = ps64_pkr251(spsToNumber((unsigned char*)&buffer[372])); // PS64 Penning
  info->ps64_data[PS64_SW1] = spsToWord((unsigned char*)&buffer[360]); // PS64 Status Word 1
  info->ps64_data[PS64_SW2] = spsToWord((unsigned char*)&buffer[362]); // PS64 Status Word 2

// temporarily decode status words
  if (count++ == 50) {
    count = 0;
/*
    value = (int)info->ps64_data[PS64_SW1];
    if ((value & LV_BIT0) && (value & LV_BIT3)) // pump on and running > 80%
      cm_msg(MDEBUG, "ps64_decode_data", "Turbo On");
    else if (value & LV_BIT1) // pump off
      cm_msg(MDEBUG, "ps64_decode_data", "Turbo Off");
    else if (value & LV_BIT2) // running high
      cm_msg(MDEBUG, "ps64_decode_data", "Turbo Running High");
    else if (!(value & LV_BIT2) && (value & LV_BIT0) && !(value & LV_BIT3))
      cm_msg(MDEBUG, "ps64_decode_data", "Turbo On but <80%%");
    if ((value & LV_BIT11) && !(value & LV_BIT12))
      cm_msg(MDEBUG, "ps64_decode_data", "Prepump On");
    else if (!(value & LV_BIT11) && (value & LV_BIT12))
      cm_msg(MDEBUG, "ps64_decode_data", "Prepump Off");

    value = (int)info->ps64_data[PS64_SW2];
    if (value & LV_BIT0) { // pump station manually off
      cm_msg(MDEBUG, "ps64_decode_data", "PS64 pump station manually off!");
    } else if (value & LV_BIT3)
      cm_msg(MDEBUG, "ps64_decode_data", "PS64 TCP turbo controller error!");
    else if (value & LV_BIT4) {
      cm_msg(MDEBUG, "ps64_decode_data", "PS64 turbo pump error!");
    }
*/
  }

  return TRUE;
}

//----------------------------------------------------------------------------
void ps64_get_all(PS64_INFO *info)
{
  INT  status;
  char data[SPS_MAX_BYTES];
  DWORD now;

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

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

  // get data
  status = info->bd(CMD_READ, info->bd_info, &data[0], sizeof(data), 3000); // read data
  if (info->intern.detailed_msg) {
    cm_msg(MDEBUG, "ps64_get_all", "ps64_get_all: get data (status=%d)", status);
    cm_yield(0);
  }
  if (status == SPS_MAX_BYTES) {
    memcpy(info->ps64_buffer, data, SPS_MAX_BYTES);
    // feed readback diagnostic array
    now = ss_time();
    if (info->last_success == 0) {
      info->last_success = now;
    } else {
      //as THE FOLLOWING DIAGNOSTIC PART SHOULD BE REMOVED WHEN TESTING HAS FINISHED.
      if (now - info->last_success <= 1.0)
        info->ps64_diag[0]++;
      else if (now - info->last_success <= 2.0)
        info->ps64_diag[1]++;
      else if (now - info->last_success <= 3.0)
        info->ps64_diag[2]++;
      else if (now - info->last_success <= 5.0)
        info->ps64_diag[3]++;
      else
        info->ps64_diag[4]++;
      info->last_success = now;
    }
  } else {
    if (info->intern.detailed_msg) {
      cm_msg(MINFO, "ps64_get_all", "ps64_get_all: get.data.status=%d", status);
      cm_yield(0);
    }
    info->read_counts++;
    info->ps64_diag[5]++;
  }

  // check for errors
  // (error byte set) or (haven't gotten all the data)
  if (status != SPS_MAX_BYTES) {
    info->read_error++;
    return;
  } else {
    info->read_counts = 0;
    if (!ps64_decode_data(info, data)) {
      info->read_error++;
    }
  }

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

//----------------------------------------------------------------------------
void ps64_write_cmd(PS64_INFO *info)
{
  int status;

  info->tcpip_open_error = 0;

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

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

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

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

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

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

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


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

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

  // initialize driver
  gInfo->bd = bd;                 // keep the bus driver entry function
  gInfo->bd_info = 0;             // initialize the pointer to the BD info structure
  gInfo->time = ss_time();        // timer for error handling
  gInfo->errTime = ss_time();     // timer for error handling
  gInfo->read_error = 0;          // read error counter
  gInfo->tcpip_open_error = 0;    // open tcpip error counter
  gInfo->read_counts = 0;         // counter how often tcpip reading has benn attempt
  gInfo->last_success = 0;

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

  // initialize ps64 status message
  cm_msg(MINFO, "ps64_init", "ps64 initialized ...");
  cm_yield(0);

  return FE_SUCCESS;
}

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

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

  return FE_SUCCESS;
}

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

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

  free(info);
  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT ps64_in_get_label(PS64_INFO *info, INT channel, char *name)
{
  strcpy(name, info->ps64_names.in_name[channel]);
  return FE_SUCCESS;
}

//----------------------------------------------------------------------------
INT ps64_out_get_label(PS64_INFO *info, INT channel, char *name)
{
  strcpy(name, info->ps64_names.out_name);
  return FE_SUCCESS;
}

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

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

  *pvalue = info->ps64_data[channel];

  ss_sleep(10);
  return FE_SUCCESS;
}

void ps64_start_pump(PS64_INFO *info)
{
  cm_msg(MDEBUG, "ps64_start_pump", "ps64_start_pump: will start pump ...");
  cm_yield(0);

  info->ps64_buffer[376] = (char)1; // PS_On command
  ps64_write_cmd(info);
}

void ps64_stop_pump(PS64_INFO *info)
{
  cm_msg(MDEBUG, "ps64_stop_pump", "ps64_stop_pump: will stop pump ...");
  cm_yield(0);

  info->ps64_buffer[376] = (char)2; // PS_Off command
  ps64_write_cmd(info);
}


INT ps64_set(PS64_INFO *info, INT channel, float value)
{
  HNDLE hKey;
  int size;
  float fval;

  if (value == 0)
    return FE_SUCCESS;

  if (value == 1)
    ps64_start_pump(info);
  else if (value == 2)
    ps64_stop_pump(info);

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

  return FE_SUCCESS;
}

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

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

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

    default:
      break;
    }

  va_end(argptr);

  return status;
}

INT ps64_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 = ps64_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);
      status = ps64_set(info, channel, value);
      break;

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

    default:
      break;
    }

  va_end(argptr);

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