xtc.c

Go to the documentation of this file.

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

  Name:         xtc.c

  Created by:   Andreas Suter  2001/09/04
                based on Stefan Ritt's multi device driver

  Contents:     device driver for the XTC thin film thickness and rate monitor.

  RS232:        9600 baud, 8 data bits, 1 stop bit, no parity bit,
                protocol: none, termination: 0x06 (ACK)

  driver:       the first channel is the thickness, the second one the rate.

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

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

#include "ets_logout.h"

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

#define XTC_ETS_LOGOUT_SLEEP 10000

#define XTC_MAX_READBACK_FAILURE 5

#define XTC_INIT_ERROR -2
#define XTC_READ_ERROR -1

#define XTC_CHANNELS 2

typedef struct {
  INT   detailed_msg;           
  INT   ets_in_use;             
  char  name[XTC_CHANNELS][32]; 
} XTC_SETTINGS;

#define XTC_SETTINGS_STR "\
Detailed Messages = INT : 0\n\
ETS_IN_USE = INT : 1\n\
Name_1 = STRING : [32] XTC_Thickness\n\
Name_2 = STRING : [32] XTC_Rate\n\
"

typedef struct {
  XTC_SETTINGS xtc_settings;    
  INT num_channels;             
  INT (*bd)(INT cmd, ...);      
  void *bd_info;                
  HNDLE hkey;                   
  INT   errorcount;             
  INT   startup_error;          
  DWORD lasterrtime;            
  int   bd_connected;           
  INT   readback_failure;       
  DWORD last_reconnect;         
  float last_value;             
  int   reconnection_failures;  
} XTC_INFO;

#define TIME_OUT_XTC 2000

/* --------- to handle error messages ------------------------------*/
#define MAX_ERROR 4           
#define DELTA_TIME_ERROR 3600 
#define ACK 0x06              
#define DEBUG FALSE           

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

INT xtc_init(HNDLE hKey, void **pinfo, INT channels, INT (*bd)(INT cmd, ...))
{
  INT       status;
  char      cmd[8], ack[2], str[32];
  HNDLE     hDB, hkeydd;
  XTC_INFO  *info;

  cm_get_experiment_database(&hDB, NULL);

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

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

  // Hot-link onto the device driver ODB entry (private stuff of the device driver)
  db_find_key(hDB, hKey, "DD", &hkeydd);
  db_open_record(hDB, hkeydd, &info->xtc_settings, sizeof(info->xtc_settings), MODE_READ, NULL, NULL);

  // initialize driver
  info->num_channels          = channels;
  info->bd                    = bd;
  info->hkey                  = hKey;
  info->errorcount            = 0;
  info->startup_error         = 0;
  info->lasterrtime           = ss_time();
  info->bd_connected          = 0;
  info->readback_failure      = 0;
  info->last_reconnect        = ss_time();
  info->reconnection_failures = 0;

  if ( info->num_channels > XTC_CHANNELS ) {
     cm_msg(MERROR,"xtc_init", "Error, number of XTC channels %d exceeds maximum of allowed channels", info->num_channels);
     cm_yield(0);
     info->startup_error = 1;
     return FE_SUCCESS;
  }

  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;
    return status;
  }
  info->bd_connected = 1; // bus driver successfully connected

  sprintf(ack, "%c", ACK);   // terminater
  sprintf(cmd, "D%s", ack);  // command

  if ( info->bd_connected ) {
    BD_PUTS(cmd);
    status = BD_GETS(str, sizeof(str), ack, TIME_OUT_XTC);
  }

  if ( status != 26) {
    info->startup_error = 1;
    cm_msg(MINFO, "xtc_init", "XTC startup error.");
    cm_yield(0);
  } else {
    cm_msg(MINFO, "xtc_init", "XTC driver initialized.");
    cm_yield(0);
  }

  return FE_SUCCESS;
}

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

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

  free(info);

  return FE_SUCCESS;
}

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

INT xtc_set(XTC_INFO *info, INT channel, float value)
{
  return FE_SUCCESS;
}

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

INT xtc_get(XTC_INFO *info, INT channel, float *pvalue)
{
char  str[128], substr[128], ack[2], cmd[128];
INT   status = 0;
DWORD nowtime, difftime;

  nowtime  = ss_time();
  difftime = nowtime - info->lasterrtime;
  if ( difftime > DELTA_TIME_ERROR ) {
    info->errorcount  = 0;
    info->lasterrtime = nowtime;
  }

  if ( info->startup_error == 1 ) {   // error during CMD_INIT, return -2
    *pvalue = (float) XTC_INIT_ERROR;
    ss_sleep(10); // to keep CPU load low when Run active
    return FE_SUCCESS;
  }

  if (info->reconnection_failures > 5) {
    *pvalue = (float) XTC_READ_ERROR;
    if (info->reconnection_failures == 6) {
      cm_msg(MERROR, "xtc_get", "too many reconnection failures, bailing out :-(");
      info->reconnection_failures++;
    }
    return FE_SUCCESS;
  }

  sprintf(ack, "%c", ACK);   // terminater
  sprintf(cmd, "D%s", ack);  // command

  if ( info->bd_connected ) {
    BD_PUTS(cmd);
    status = BD_GETS(str, sizeof(str), ack, TIME_OUT_XTC);
  }

  if ( status != 26) {
    *pvalue = (float) info->last_value;
    if (info->errorcount < MAX_ERROR) {
      if (info->xtc_settings.detailed_msg)
        cm_msg(MERROR, "xtc_get", "XTC: command error.");
      info->errorcount++;
    }

    info->readback_failure++;

    if (info->readback_failure == XTC_MAX_READBACK_FAILURE) {
      info->readback_failure = 0;
      // try to disconnect and reconnect the bus driver
      if ((ss_time()-info->last_reconnect > 10) && info->bd_connected) { // disconnect bus driver
        info->bd(CMD_EXIT, info->bd_info);
        if (info->xtc_settings.detailed_msg)
          cm_msg(MINFO, "xtc_get", "xtc: try to disconnect and reconnect the bus driver");
        info->last_reconnect = ss_time();
        info->bd_connected = 0;
        if (info->xtc_settings.ets_in_use)
          ets_logout(info->bd_info, XTC_ETS_LOGOUT_SLEEP, info->xtc_settings.detailed_msg);
      }
    }

    // try to reconnect after a timeout of 10 sec
    if ((ss_time()-info->last_reconnect > 10) && !info->bd_connected) {
      if (info->xtc_settings.detailed_msg)
        cm_msg(MINFO, "xtc_get", "xtc: reconnection trial ...");
      status = info->bd(CMD_INIT, info->hkey, &info->bd_info);
      if (status != FE_SUCCESS) {
        if (info->xtc_settings.detailed_msg)
          cm_msg(MINFO, "xtc_get", "xtc: reconnection attempted failed");
        info->reconnection_failures++;
        return FE_ERR_HW;
      } else {
        info->bd_connected = 1; // bus driver is connected again
        info->reconnection_failures = 0;
        info->last_reconnect = ss_time();
        if (info->xtc_settings.detailed_msg)
          cm_msg(MINFO, "xtc_get", "xtc: successfully reconnected");
      }
    }
    return FE_SUCCESS;
  }

  switch(channel) {
    case 0:
      sscanf(str, "%s %f", substr, pvalue); // thickness in A
      break;
    case 1:
      sscanf(str, "%f ", pvalue);
      *pvalue /= 10.f;
       break;
    default:
      *pvalue = (float) XTC_READ_ERROR;
      break;
   }

   info->last_value = *pvalue; // keep the last valid value
   info->readback_failure = 0; // reset readback failure counter

   return FE_SUCCESS;
}

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

INT xtc_get_label(XTC_INFO *info, INT channel, char *name)
{
  strcpy(name, info->xtc_settings.name[channel]);

  return FE_SUCCESS;
}


/*---- device driver entry point -----------------------------------*/

INT xtc(INT cmd, ...)
{
va_list argptr;
HNDLE   hKey;
INT     channel, status;
DWORD   flags;
void    *info, *bd;
float   value, *pvalue;
char    *name;

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

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

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

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

    default:
      break;
  }
  va_end(argptr);
  return status;
}
/*------------------------------------------------------------------*/