sics/oscillate.c

/*-----------------------------------------------------------------------
  Oscillator runs a motor back and forth between its software limits.
  
  copyright: see file COPYRIGHT

  Mark Koennecke, November 2004
------------------------------------------------------------------------*/
#include <stdio.h>
#include <assert.h>
#include <tcl.h>
#include "fortify.h"
#include "sics.h"
#include "task.h"
#include "commandlog.h"
#include "oscillate.h"

#define ABS(x) (x < 0 ? -(x) : (x))    

/*================== real work =========================================*/
static void StopOscillation(pOscillator self){
  assert(self != NULL);
  if(self->taskID > 0){
    self->pMot->pDriver->Halt(self->pMot->pDriver);
    self->stopFlag = 1;
    self->taskID = -1;
  }
  MotorSetPar(self->pMot,self->pCon,"accesscode",usUser);
  if(self->debug > 0){
    WriteToCommandLog("oscillator>> ","Stopping");
  }
}
/*-------------------------------------------------------------------*/
static float getNextPos(pOscillator self){
  float pos;
  if(self->nextTargetFlag == 1){
    pos = self->upperLimit;
    self->nextTargetFlag = 0;
  } else {
    pos = self->lowerLimit;
    self->nextTargetFlag = 1;
  }
  return pos;
}
/*-------------------------------------------------------------------*/
static float getCurrentTarget(pOscillator self){
  float pos;
  if(self->nextTargetFlag == 1){
    pos = self->lowerLimit;
  } else {
    pos = self->upperLimit;
  }
  return pos;
}
/*---------------------------------------------------------------------*/
static int OscillationTask(void *data){
  pOscillator self = (pOscillator)data;
  int status, code, errStatus;
  char error[256], message[132];
  float pos, curPos;


  assert(self);
  if(self->stopFlag == 1){
    return 0;
  }

  status = self->pMot->pDriver->GetStatus(self->pMot->pDriver);
  switch(status){
  case HWFault:
  case HWPosFault:
    self->pMot->pDriver->GetError(self->pMot->pDriver,&code,error,255);
    WriteToCommandLog("oscillator>> ",error);
    pos = getCurrentTarget(self);
    errStatus = self->pMot->pDriver->TryAndFixIt(self->pMot->pDriver,code,pos);
    self->errorCount++;
    if(errStatus == MOTFAIL){
      /*
	try driving the other way on a serious error
      */
      pos = getNextPos(self);
      status = MotorRun(self->pMot,self->pCon,pos);
      if(self->debug > 0){
	snprintf(message,131,"Started oscillation to %f, ret code = %d",
		 pos,status);
	WriteToCommandLog("oscillator>>",message);
      }
    }
    break;
  case HWWarn:
    MotorGetSoftPosition(self->pMot,self->pCon,&curPos);
    pos = getCurrentTarget(self);
    if(ABS(curPos - pos) < .5){
      status = MotorRun(self->pMot,self->pCon,getNextPos(self));
    } 
    break;
  case HWBusy:
    break;
  case HWIdle:
    pos = getNextPos(self);
    status = MotorRun(self->pMot,self->pCon,pos);
    if(status == OKOK){
      self->pMot->pDrivInt->iErrorCount = 0;
    }
    if(self->debug > 0){
      snprintf(message,131,"Started oscillation to %f, ret code = %d",
	       pos,status);
      WriteToCommandLog("oscillator>>",message);
    }
  }
  return 1;
}
/*--------------------------------------------------------------------*/
static int StartOscillation(pOscillator self, SConnection *pCon){
  float fval;
  int status;
  char error[80], pBueffel[255];  

  assert(self);

  if(self->taskID > 0){
    SCWrite(pCon,"WARNING: oscillation already running",eWarning);
    SCWrite(pCon,"WARNING: restarting .. ",eWarning);
    StopOscillation(self);
    SicsWait(2);
  } 

  MotorGetPar(self->pMot,"softlowerlim",&self->lowerLimit);
  self->lowerLimit += .5;
  MotorGetPar(self->pMot,"softupperlim",&self->upperLimit);
  self->upperLimit -= .5;
  MotorSetPar(self->pMot,self->pCon,"accesscode",(float)usInternal);
  self->nextTargetFlag = 0;
  self->errorCount = 0;
  self->stopFlag = 0;

  /*
    check reachability of limits
  */
  status = MotorCheckBoundary(self->pMot,self->lowerLimit,&fval,error,79);
  if(!status){
    snprintf(pBueffel,255,"ERROR: cannot reach %f: %s reported",
	     self->lowerLimit,error);
    SCWrite(pCon,pBueffel,eError);
    return 0;
  }
  status = MotorCheckBoundary(self->pMot,self->upperLimit,&fval,error,79);
  if(!status){
    snprintf(pBueffel,255,"ERROR: cannot reach %f: %s reported",
	     self->upperLimit,error);
    SCWrite(pCon,pBueffel,eError);
    return 0;
  }

  /*
    start task
  */
  self->taskID = TaskRegister(pServ->pTasker,
			      OscillationTask,
			      NULL,
			      NULL,
			      self,
			      10);
  if(self->taskID < 0){
    SCWrite(pCon,"ERROR: failed to start oscillation task",eError);
    return 0;
  }
  return 1;
}
/*===================== life and death =================================*/
static void KillOscillator(void *data){
  pOscillator self = (pOscillator)data; 
  if(self != NULL){
    if(self->pDes != NULL){
      DeleteDescriptor(self->pDes);
    }
    if(self->pCon != NULL){
      SCDeleteConnection(self->pCon);
    }
    free(self);
  }
}
/*========================================================================*/
int MakeOscillator(SConnection *pCon, SicsInterp *pSics, void *pData,
		   int argc, char *argv[]){
  pOscillator pNew = NULL;
  pMotor pMot = NULL;
  char pBueffel[132];
  int status;

  if(argc < 3){
    SCWrite(pCon,"ERROR: insufficient number of arguments to MakeOscilator",
	    eError);
    return 0;
  }

  pMot = FindMotor(pSics,argv[2]);
  if(pMot == NULL){
    snprintf(pBueffel,131,"ERROR: %s is no motor",argv[2]);
    SCWrite(pCon,pBueffel,eError);
    return 0;
  }

  pNew = (pOscillator)malloc(sizeof(Oscillator));
  if(pNew == NULL){
    SCWrite(pCon,"ERROR: out of memory creating oscillator",eError);
    return 0;
  }
  memset(pNew,0,sizeof(Oscillator));
  pNew->pDes = CreateDescriptor("Oscillator");
  pNew->pMot = pMot;
  pNew->pCon = SCCreateDummyConnection(pSics);
  if(!pNew->pDes || !pNew->pCon){
    SCWrite(pCon,"ERROR: out of memory creating oscillator",eError);
    return 0;
  }
  SCSetWriteFunc(pNew->pCon,SCFileWrite);
  SCSetRights(pNew->pCon,usInternal);
  
  status = AddCommand(pSics,argv[1],
		      OscillatorWrapper,
		      KillOscillator,
		      pNew);
  if(!status){
    snprintf(pBueffel,131,"ERROR: duplicate command %s not created",argv[1]);
    SCWrite(pCon,pBueffel,eError);
    return 0;
  }
  return 1;
}
/*========================================================================*/
int OscillatorWrapper(SConnection *pCon, SicsInterp *pSics, void *pData,
		      int argc, char *argv[]){
  pOscillator self = (pOscillator)pData;
  char pBueffel[256];

  assert(self);
  if(argc < 2){
    SCWrite(pCon,"ERROR: need start/stop argument for oscillator",eError);
    return 0;
  }

  if(!SCMatchRights(pCon,usUser)){
    return 0;
  }
  
  strtolower(argv[1]);
  if(strcmp(argv[1],"start") == 0){
    return StartOscillation(self,pCon);
  } else if(strcmp(argv[1],"stop") == 0) {
    StopOscillation(self);
    snprintf(pBueffel,255,"Oscillation stopped with %d errors, %s",
	     self->errorCount,
	     "see commandlog for details");
    SCWrite(pCon,pBueffel,eValue);
    return 1;
  } else if(strcmp(argv[1],"debug") == 0) {
    if(argc >= 3){
      self->debug = atoi(argv[2]);
      SCSendOK(pCon);
      return 1;
    }
    snprintf(pBueffel,255,"%s.debug = %d", argv[0],self->debug);
    SCWrite(pCon,pBueffel,eValue);
    return 1;
  } else if(strcmp(argv[1],"status") == 0) {
    if(self->taskID > 0){
      snprintf(pBueffel,255,"Oscillation running, %d errors so far, %s",
	       self->errorCount,
	       " error details in commandlog");
    } else {
      snprintf(pBueffel,255,"Oscillation stopped");
    }
    SCWrite(pCon,pBueffel,eValue);
    return 1;
  } else {
    SCWrite(pCon,"ERROR: invalid sub command for oscillator requested",
	    eError);
    return 0;
  }
  return 1;
}