sics/tecs/tecs_cli.c

#include <stdlib.h>
#include <string.h>
#include "err_handling.h"
#include "str_util.h"
#include "tecs_cli.h"

static char device[80], command[80];
static int quit, readTemp, configuring;
static float tempX, tempP, tempC;

pTecsClient TeccInit(char *startcmd, int port) {
  CocConn *conn;

  ERR_SP(conn=(CocConn *)my_malloc(sizeof(*conn),"conn"));
  ERR_I(CocInitClient(conn, "", port, "#rwacs", 0, startcmd));
  CocDefFlt(tempC, CocRD);
  CocDefFlt(tempP, CocRD);
  CocDefFlt(tempX, CocRD);
  CocDefStr(device, CocWR);
  CocDefInt(configuring, CocRD);
  CocDefInt(quit, CocWR);
  CocDefInt(readTemp, CocWR);
  CocDefCmd(command);

  return((pTecsClient)conn);
  OnError: return(NULL);
}

int TeccGet3(pTecsClient conn, float *tC, float *tX, float *tP) {
  readTemp=1;
  ERR_I(CocCmd(conn, "tempC,tempX,tempP,[readTemp],configuring"));
  *tC=tempC;
  *tX=tempX;
  *tP=tempP;
  return(configuring);
  OnError: return(-1);
}

int TeccGet(pTecsClient conn, float *temp) {
  ERR_I(CocCmd(conn, "tempP,[readTemp],configuring"));
  *temp=tempP;
  return(configuring);
  OnError: return(-1);
}

int TeccWait(pTecsClient conn) {
  int last, cnt;
  last=0;
  cnt=0;
  do {
    CocDelay(250);
    ERR_I(CocCmd(conn, "configuring"));  
    if (configuring==last || configuring>1000) {
      cnt++;
      if (cnt>20) ERR_MSG("configuring timeout");
    } else {
      cnt=0;
      last=configuring;
    }
  } while (configuring>0);
  return(0);
  OnError: return(-1);
}

int TeccSet(pTecsClient conn, float temp) {
  tempC=temp;
  ERR_I(CocCmd(conn, "[tempC]"));
  return(0);
  OnError: return(-1);
}

int TeccSend(pTecsClient conn, char *cmd, char *reply, int replyLen) {
  char *res;
  int cnt;

  str_copy(command, cmd);
  ERR_I(CocCmd(conn, "[$]"));
  cnt=40;
  CocDelay(100);
  while (cnt>0) {
    ERR_I(CocCmd(conn, "$"));
    if (command[0]!='\0') {
      str_ncpy(reply, command, replyLen);
      return(0);
    }
    CocDelay(250);
    cnt--;
  }
  str_ncpy(reply, "<no response>", replyLen);
  return(0);
  OnError: return(-1);
}

int TeccQuitServer(pTecsClient conn) {
  quit=1;
  ERR_I(CocCmd(conn, "[quit]"));
  return(0);
  OnError: return(-1);
}

void TeccClose(pTecsClient conn) {
  if (conn!=NULL) {
    CocCloseClient(conn);
    my_free(conn);
  }
}

/* fortran interface ---------------- */

int tecc_set_par_(pTecsClient *conn, char *name, char *par, int namelen, int parlen) {
  char nbuf[64], pbuf[256];

  if (namelen>=sizeof(nbuf)) namelen=sizeof(nbuf)-1;
  strncpy(nbuf, name, namelen);
  while (namelen>0 && nbuf[namelen-1]==' ') namelen--; /* trim */
  nbuf[namelen]='\0';

  if (parlen>=sizeof(pbuf)) parlen=sizeof(pbuf)-1;
  strncpy(pbuf, par, parlen);
  while (parlen>0 && pbuf[parlen-1]==' ') parlen--; /* trim */
  pbuf[parlen]='\0';

  ERR_I(CocSet(*conn, nbuf, pbuf));

  return(0);
  OnError: return(-1);
}

int tecc_get_par_(pTecsClient *conn, char *name, char *par, int namelen, int parlen) {
  int l;
  char nbuf[64], pbuf[256];

  if (namelen>=sizeof(nbuf)) namelen=sizeof(nbuf)-1;
  strncpy(nbuf, name, namelen);
  while (namelen>0 && nbuf[namelen-1]==' ') namelen--; /* trim */
  nbuf[namelen]='\0';

  ERR_I(CocGet(*conn, nbuf, pbuf));

  l=strlen(pbuf);
  if (l>parlen) l=parlen;
  strncpy(par, pbuf, l);
  return(l);
  OnError: return(-1);
}

int tecc_send_(pTecsClient *conn, char *cmd, char *reply, int cmdlen, int replylen) {
  int l;
  char cbuf[80], rbuf[80];

  if (cmdlen>=sizeof(cbuf)) cmdlen=sizeof(cbuf)-1;
  strncpy(cbuf, cmd, cmdlen);
  while (cmdlen>0 && cbuf[cmdlen-1]==' ') cmdlen--; /* trim */
  cbuf[cmdlen]='\0';

  ERR_I(TeccSend(*conn, cbuf, rbuf, sizeof(rbuf)));

  l=strlen(rbuf);
  if (l>replylen) l=replylen;
  strncpy(reply, rbuf, l);
  return(l);
  OnError: return(-1);
}

pTecsClient tecc_init_(char *server, int *port, int serverlen) {
  char sbuf[132];

  if (serverlen>=sizeof(sbuf)) serverlen=sizeof(sbuf)-1;
  strncpy(sbuf, server, serverlen);
  while (serverlen>0 && sbuf[serverlen-1]==' ') serverlen--; /* trim */
  sbuf[serverlen]='\0';
  return(TeccInit(sbuf, *port));
}

#ifdef __VMS
#define tecc_get_ tecc_get
#define tecc_get3_ tecc_get3
#define tecc_set_ tecc_set
#define tecc_wait_ tecc_wait
#define tecc_close_ tecc_close
#define tecc_quit_server_ tecc_quit_server
#endif

int tecc_get_(pTecsClient *conn, float *temp) {
  return(TeccGet(*conn, temp));
}

int tecc_get3_(pTecsClient *conn, float *t1, float *t2, float *t3) {
  return(TeccGet3(*conn, t1, t2, t3));
}

int tecc_set_(pTecsClient *conn, float *temp) {
  return(TeccSet(*conn, *temp));
}

int tecc_wait_(pTecsClient *conn) {
  return(TeccWait(*conn));
}

void tecc_close_(pTecsClient *conn) {
  TeccClose(*conn);
}

int tecc_quit_server_(pTecsClient *conn) {
  return(TeccQuitServer(*conn));
}

#ifdef __VMS

typedef struct { short size, dummy; char *text; } Desc;

pTecsClient tecc_init(Desc *server, int *port, int serverlen) {
  return(tecc_init_(server->text, port, server->size));
}

int tecc_set_par(pTecsClient *conn, Desc *name, Desc *par) {
  return(tecc_set_par_(conn, name->text, par->text, name->size, par->size));
}

int tecc_get_par(pTecsClient *conn, Desc *name, Desc *par) {
  return(tecc_get_par_(conn, name->text, par->text, name->size, par->size));
}

int tecc_send(pTecsClient *conn, Desc *cmd, Desc *reply) {
  return(tecc_send_(conn, cmd->text, reply->text, cmd->size, reply->size));
}

#endif