/**
* This is the implementation of a chopper driver for the MARS Chopper cascade
* as provided by the Forschungszentrum Juelich. The original host protocol 
* from Juelich has been changed on our request; Gerd Theidel did some of that 
* Turbo Pascal coding.
*
* copyright: see file COPYRIGHT
*
* Mark Koennecke, June-July 2006
* 
* Parameter updating is to  slow, therefore it happens in two groups now: 
* actspeed and actphase are requested more frequently, so they go separate
* 
* Mark Koennecke, October 2006
*/
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <sics.h>
#include <unistd.h>
#define CHOCOINTERNAL
#include <choco.h>
#include <SCinter.h> 
#include <rs232controller.h>
#include <sicshipadaba.h>
#include <stptok.h>
#include <dynstring.h>
/*----------------------------- error codes  -----------------------------*/
#define FRAMEERROR -801
#define CKERROR    -802
#define BADCOMMAND -803
#define WRONGNOPAR -804
#define ILLPAR     -805
#define PARRANGE   -806
#define BADERR     -807
#define BADREPLY   -808
#define NOTPAR     -809
#define BADTEXT    -810
#define ROPAR      -811
#define NOMEM      -812
#define HALT       -813
/*--------------------- update flags -------------------------------------*/
#define ALL 1
#define SPEED 2
/*--------------------- wait after set -----------------------------------*/
#define STWAIT 5
/*------------------------- chopper internal names -----------------------*/
#define CH1N "snail"
#define CH2N "master"
#define CH3N "rabbit"
#define CH4N "four"
#define CH5N "five"
/*=============== Juelich chopper private data structure ================== */
typedef struct {
            prs232 controller;
            pHdb parNode;
            int errorCode;
            time_t lastUpdate;
            int updateIntervall;
            int speedUpdate;
            int halt;
}JulCho, *pJulCho;
/*------------------------------------------------------------------------*/
typedef struct {
        char prefix[10];
        char postfix[10];
        char comCode[10];
        pJulCho pDriv;
} julCBData, *pJulCBData;
/*================= internal support functions ============================*/
static int calculateJulCheckSum(char *realCommand){
    int i, checkSum = 0;
    
    for(i = 1; i < strlen(realCommand); i++){
        checkSum += (int)realCommand[i];
    }   
    return checkSum;
}
/*------------------------------------------------------------------------*/
static int testJulError(char *reply){
    char *pPtr = NULL, *pEnd = NULL;
    int code, status;
    
    if(strstr(reply,"ERR") == NULL){
        return 1;
    }
    pPtr = &reply[9]; /* #ERR:CCC: */
    pEnd = strchr(pPtr,'{');
    if(pEnd == NULL){
        return BADERR;
    }
    *pEnd = '\0';
    code = atoi(pPtr);
    switch(code){
        case 1:
            status = FRAMEERROR;
            break;
        case 2:
            status = CKERROR;
            break;
        case 3:
            status = BADCOMMAND;
            break;
        case 4:
            status = WRONGNOPAR;
            break;
        case 5:
            status = ILLPAR;
            break;
        case 6:
            status = PARRANGE;
            break;
        default:
            status = BADERR;
            break;
    }
    return status;
}
/*------------------------------------------------------------------------*/
static void readClean(prs232 controller){
    char buffer[1024];
    int count = 0, bufSize;
    
    while(availableRS232(controller) == 1 && count < 20){
        bufSize = 1024;
        readRS232(controller,buffer, &bufSize);
    }   
}
/*-------------------------------------------------------------------------*/
static int JulChoTransact(pJulCho self, char *command, 
    char *reply, int replyLen){
    int status, length, checkSum;
    char realCommand[1024], checkString[30];
    
    strcpy(realCommand,"#");
    strcat(realCommand,command);
    
    checkSum = calculateJulCheckSum(realCommand);
    snprintf(checkString,30,"{%d}$", checkSum);
    strcat(realCommand,checkString);
    
    /*
     * clean the socket: If someone whacked the keyboard and the
     * controller did not repsond, the line might be full of shit
     */
    readClean(self->controller);
    
    status = transactRS232(self->controller, realCommand,strlen(realCommand), 
        (void *)reply, replyLen);
    if(status <= 0){
        return status;
    }

    status = testJulError(reply);    
                 
    return status;
} 
/*---------------------------------------------------------------------------*/
static hdbCallbackReturn JulChoSetCallback(pHdb node, void *userData, 
		pHdbMessage message){
    pJulCBData cbData = NULL;
    char command[256], reply[256];
    pHdbDataMessage mm = NULL;
    int status;
    
    cbData = (pJulCBData)userData;
    if(cbData == NULL){
        return hdbContinue;
    }
 
    /*
     * Is this for us?
     */
    mm = GetHdbSetMessage(message);
    if(mm == NULL){
    	return hdbContinue;
    }
    
    
    if(mm->v->dataType == HIPINT){
        snprintf(command,255,"%s %s%d%s",cbData->comCode, cbData->prefix,
            (int)mm->v->v.intValue,cbData->postfix);
    } else if(mm->v->dataType == HIPFLOAT){
        snprintf(command,255,"%s %s%f%s",cbData->comCode, cbData->prefix,
            (float)mm->v->v.doubleValue,cbData->postfix);
    } else {
        assert(0); /* this is a programming error */
    }
    
    cbData->pDriv->halt = 0;
    status = JulChoTransact(cbData->pDriv, command, reply, 255);
    if(status < 0) {
            cbData->pDriv->errorCode = status;
            return hdbAbort;
    }
    return hdbContinue;
}
/*------------------------------------------------------------------------------*/
static pHdbCallback MakeJulChoSetCallback(pJulCho driv, char *command, 
    char *prefix, char *postfix){
    pJulCBData cbData = NULL;
    pHdbCallback hdbCB = NULL;
    
    hdbCB = malloc(sizeof(hdbCallback));
    cbData = malloc(sizeof(julCBData));
    if(cbData == NULL || hdbCB == NULL){
        return NULL;
    }
    cbData->pDriv = driv;
    strncpy(cbData->comCode,command,9);        
    strncpy(cbData->prefix,prefix,9);        
    strncpy(cbData->postfix,postfix,9);   
    hdbCB->next = NULL;     
    hdbCB->previous = NULL;     
    hdbCB->killFunc = free;
    hdbCB->userCallback = JulChoSetCallback;
    hdbCB->userData = cbData;
    return hdbCB;     
}
/*--------------------------------------------------------------------------*/
static int splitJulChoInt(char *reply, int data[5]){
    char number[10];
    char *pPtr = NULL;
    int count = 0;
    
    pPtr = stptok(reply,number,10,":");
    pPtr = stptok(pPtr,number,10,":");
    while(pPtr != NULL && count < 5){
        data[count] = atoi(number);
        count++;
        pPtr = stptok(pPtr,number,10,":");
    }
    if(count < 4){
        return 0;
    } 
    return 1;
}
/*--------------------------------------------------------------------------*/
static int splitJulChoDouble(char *reply, double data[5]){
    char number[10];
    char *pPtr = NULL;
    int count = 0;
    
    pPtr = stptok(reply,number,10,":");
    pPtr = stptok(pPtr,number,10,":");
    while(pPtr != NULL && count < 5){
        data[count] = (double)atof(number);
        count++;
        pPtr = stptok(pPtr,number,10,":");
    }
    if(count < 4){
        return 0;
    } 
    return 1;
}
/*--------------------------------------------------------------------------*/
static int setJulChoIntPar(pHdb root, char *par, int data[5]){
    char path[256];
    hdbValue v;
    pHdb node = NULL;
    
    memset(&v,0,sizeof(hdbValue));
    v.dataType = HIPINT;
    
    snprintf(path,255,"%s/%s",CH1N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.intValue = (long)data[0];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH2N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.intValue = (long)data[1];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH3N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.intValue = (long)data[2];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH4N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.intValue = (long)data[3];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH5N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.intValue = (long)data[4];
    UpdateHipadabaPar(node,v,NULL);
    
    return 1;
}
/*--------------------------------------------------------------------------*/
static int setJulChoDoublePar(pHdb root, char *par, double data[5]){
    char path[256];
    hdbValue v;
    pHdb node = NULL;
    
    memset(&v,0,sizeof(hdbValue));
    v.dataType = HIPFLOAT;
    
    snprintf(path,255,"%s/%s",CH1N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.doubleValue = data[0];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH2N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.doubleValue = data[1];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH3N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.doubleValue = data[2];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH4N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.doubleValue = data[3];
    UpdateHipadabaPar(node,v,NULL);

    snprintf(path,255,"%s/%s",CH5N,par);
    node = GetHipadabaNode(root,path);
    assert(node != NULL);
    v.v.doubleValue = data[4];
    UpdateHipadabaPar(node,v,NULL);
    
    return 1;
}
/*--------------------------------------------------------------------------*/
static void updateJulChoFlag(pHdb node, char *choppername, char *parname,
    int code, int mask){
    char path[256];
    hdbValue v;
    pHdb target = NULL;
    
    v.dataType = HIPINT;
    snprintf(path,255,"%s/%s",choppername,parname);
    if((mask & code) > 0) {
        v.v.intValue = 1;
    } else {
        v.v.intValue = 0;
    }
    target = GetHipadabaNode(node,path);
    assert(target != NULL);
    UpdateHipadabaPar(target,v,NULL);
}
/*---------------------------------------------------------------------------*/
static int setJulChoFlags(pHdb node, int intData[5]){
    char *chNames[] = {CH1N,
                       CH2N,
                       CH3N,
                       CH4N,
                       CH5N,
                       NULL};
    char path[256];
    int i, code;
    hdbValue v;
    
    memset(&v,0,sizeof(hdbValue));
    v.dataType = HIPINT;
    for(i = 0; i < 5; i++){
        code = intData[i];
        updateJulChoFlag(node,chNames[i],"microok",code,1);
        updateJulChoFlag(node,chNames[i],"atspeed",code,2);
        updateJulChoFlag(node,chNames[i],"atphase",code,4);
        updateJulChoFlag(node,chNames[i],"magneton",code,8);
        updateJulChoFlag(node,chNames[i],"dcon",code,16);
        updateJulChoFlag(node,chNames[i],"driveon",code,32);
        updateJulChoFlag(node,chNames[i],"currentdc",code,64);
        updateJulChoFlag(node,chNames[i],"lockopen",code,128);
        updateJulChoFlag(node,chNames[i],"diskopen",code,256);
        updateJulChoFlag(node,chNames[i],"diskclosed",code,512);
        updateJulChoFlag(node,chNames[i],"speedoverflow",code,1024);
        updateJulChoFlag(node,chNames[i],"bearingfailed",code,2048);
        updateJulChoFlag(node,chNames[i],"voltagetohigh",code,4096);
    }
    
    return 1;
}
/*--------------------------------------------------------------------------*/
static int ReadJulChoFlags(pJulCho self){
    int status, intData[5];
    char reply[256];
    
    status = JulChoTransact(self,"RSC",reply,255);
/*    fprintf(stdout,"Chopper flags = %s\n", reply);*/
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoInt(reply,intData)){
        self->errorCode = BADREPLY;
    }
    setJulChoFlags(self->parNode, intData);
    return 1;
}
/*---------------------------------------------------------------------------*/
static int UpdateJulChoParameters(pJulCho self, int what){
    int status, intData[5];
    double doubleData[5];
    char reply[255];
    
    assert(what == ALL || what == SPEED);
    
    if(what == SPEED){
        if(time(NULL) < self->speedUpdate + self->updateIntervall){
            return 1;
        }
    } else{
        if(time(NULL) < self->lastUpdate + self->updateIntervall){
            return 1;
        }
    }
    
    status = JulChoTransact(self,"RAS",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoInt(reply,intData)){
        self->errorCode = BADREPLY;
    }
    setJulChoIntPar(self->parNode,"actspeed",intData);

    status = JulChoTransact(self,"RAP",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"actphase",doubleData);

    if(what != ALL){
        self->speedUpdate = time(NULL);
        return 1;
    }
    
    status = JulChoTransact(self,"RNS",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoInt(reply,intData)){
        self->errorCode = BADREPLY;
    }
    setJulChoIntPar(self->parNode,"nomspeed",intData);
    
    
    status = JulChoTransact(self,"RNP",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"nomphase",doubleData);
    
    
    status = JulChoTransact(self,"RGW",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"gatewidth",doubleData);
    
    status = JulChoTransact(self,"RNC",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"nomcurrent",doubleData);
    
    
    status = JulChoTransact(self,"RAC",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"actcurrent",doubleData);
    
    status = JulChoTransact(self,"RAV",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"voltage",doubleData);
    
    status = JulChoTransact(self,"RIT",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"inverter_temperature",doubleData);

    status = JulChoTransact(self,"RST",reply,255);
    if(status < 0){
        self->errorCode = status;
        return 0;
    }
    if(!splitJulChoDouble(reply,doubleData)){
        self->errorCode = BADREPLY;
    }
    setJulChoDoublePar(self->parNode,"stator_temperature",doubleData);

    status = ReadJulChoFlags(self);
    
    self->lastUpdate = time(NULL);
    self->speedUpdate = time(NULL);
    return status;
}
/*------------------------------------------------------------------------*/
static void JulChoErrorcodeToString(int code, char *pError, int iLen){
    switch(code){
        case FRAMEERROR:
            strncpy(pError,"Frame error",iLen);
            break;
        case CKERROR:
            strncpy(pError,"Checksum error",iLen);
            break;
        case BADCOMMAND:
            strncpy(pError,"Bad Command",iLen);
            break;
        case WRONGNOPAR:
            strncpy(pError,"Wrong number of parameters",iLen);
            break;
        case ILLPAR:
            strncpy(pError,"Illegal parameter",iLen);
            break;
        case PARRANGE:
            strncpy(pError,"Parameter out of range",iLen);
            break;
        case BADERR:
            strncpy(pError,"Controller error not recognised",iLen);
            break;
        case BADREPLY:
            strncpy(pError,"Unexpected reply",iLen);
            break;
        case NOTPAR:
            strncpy(pError,"Unsupported parameter",iLen);
            break;
        case BADTEXT:
            strncpy(pError,"Failed to convert text to number",iLen);
            break;
        case ROPAR:
            strncpy(pError,"Read only Parameter",iLen);
            break;
        case NOMEM:
            strncpy(pError,"Out of memory formatting parameter",iLen);
            break;
        case HALT:
            strncpy(pError,"User requested HALT; choppers status undefined ",iLen);
            break;
        case SICSCBRANGE:
            strncpy(pError,"Parameter value out of range",iLen);
            break;
        case SICSCBRO:
            strncpy(pError,"Parameter is READ-ONLY",iLen);
            break;
        default:
            getRS232Error(code, pError, iLen);
            break;    
    }
}
/*------------------------------------------------------------------------*/
static int testParGroup(char *name){
    if(strstr(name,"actspeed") != NULL || 
        strstr(name,"actphase") != NULL){
            return SPEED;
        } else {
            return ALL;
        }
}
/*-------------------------------------------------------------------------*/
static hdbCallbackReturn JulChoGetCallback(pHdb currentNode, 
		void *userData, pHdbMessage message){
    pJulCho self = NULL;
    SConnection *pCon = NULL;
    int status;
    char error[128], buffer[256];
    pHdbDataMessage mm = NULL;
    
    self = (pJulCho)userData;
    assert(self != NULL);
    
    mm = GetHdbGetMessage(message);
    if(mm == NULL){
    	return hdbContinue;
    }
    pCon = (SConnection *)mm->callData;
    
    status = UpdateJulChoParameters(self,testParGroup(currentNode->name));
    if(status != 1 && pCon != NULL){
        JulChoErrorcodeToString(self->errorCode, error,127);
        snprintf(buffer,255,"ERROR: %s occurred reading par",error);
        SCWrite(pCon,buffer,eError);
    }
    return hdbContinue;
}
/*--------------------------------------------------------------------------*/
static int AppendJulChoROPar(pHdb parent, char *name, int type){
	pHdb child = NULL;
    child = AddSICSHdbROPar(parent,name,makeHdbValue(type,1));
    if(child != NULL){
    	return 1;
    } else {
    	return 0;
    }
}
/*---------------------------------------------------------------------------*/
static int ConfigureSingleJulCho(pHdb parent, pJulCho driv, 
    char *prefix, char *postfix){
    pHdb child = NULL;
    pHdbCallback pCb = NULL;
    
    /*
     * write parameters
     */
        
    child = MakeHipadabaNode("nomphase",HIPFLOAT,0);
    if(child == NULL){
        return 0;
    }
    pCb = MakeCheckPermissionCallback(usUser);
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(child,pCb); 
    pCb = MakeFloatRangeCallback(5.0, 355.);
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(child,pCb); 
    pCb = MakeJulChoSetCallback(driv,"SPH", prefix,postfix);
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(child,pCb); 
    AddHipadabaChild(parent,child,NULL);
    
    child = MakeHipadabaNode("gatewidth",HIPFLOAT,0);
    if(child == NULL){
        return 0;
    }
    pCb = MakeCheckPermissionCallback(usUser);
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(child,pCb); 
    pCb = MakeJulChoSetCallback(driv,"SGW", prefix,postfix);
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(child,pCb); 
    AddHipadabaChild(parent,child,NULL);
    
    if(!AppendJulChoROPar(parent,"nomspeed",HIPINT)){
        return 0;
    }
 
    if(!AppendJulChoROPar(parent,"actspeed",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"actphase",HIPFLOAT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"nomcurrent",HIPFLOAT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"actcurrent",HIPFLOAT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"voltage",HIPFLOAT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"inverter_temperature",HIPFLOAT)){
        return 0;
    }

    if(!AppendJulChoROPar(parent,"stator_temperature",HIPFLOAT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"microok",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"atspeed",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"atphase",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"magneton",HIPINT)){
        return 0;
    }

    if(!AppendJulChoROPar(parent,"dcon",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"driveon",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"currentdc",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"lockopen",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"diskopen",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"diskclosed",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"speedoverflow",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"bearingfailed",HIPINT)){
        return 0;
    }
    
    if(!AppendJulChoROPar(parent,"voltagetohigh",HIPINT)){
        return 0;
    }
    
    /*
     * append get callbacks 
     */
   child = parent->child;
   while(child != NULL){
        AppendHipadabaCallback(child,
            MakeHipadabaCallback(JulChoGetCallback,driv,NULL)); 
        child = child->next;
   }
   return 1;     
}
/*--------------------------------------------------------------------------*/
static int InitJulChoPar(pJulCho driv){
    pHdb child = NULL, parChild = NULL;    
    pHdbCallback pCb = NULL;
        
     
    child = MakeHipadabaNode(CH1N,HIPNONE,0); 
    if(child == NULL){
        return 0;
    }  
    if(!ConfigureSingleJulCho(child,driv,"","::::")){
        return 0;
    }
    AddHipadabaChild(driv->parNode,child,NULL);

    child = MakeHipadabaNode(CH2N,HIPNONE,0); 
    if(child == NULL){
        return 0;
    }  
    if(!ConfigureSingleJulCho(child,driv,":",":::")){
        return 0;
    }
    /**
     * the master speed can be set, the slaves not, thus remove the read only 
     * set callback and replace by a speed setting callback
     */
    parChild = GetHipadabaNode(child,"nomspeed");
    assert(parChild != NULL);
    /*
     * delete the callback cahin in order to remove the 
     * read only callback
     */
    DeleteCallbackChain(parChild);
    parChild->callBackChain = NULL;

    pCb = MakeCheckPermissionCallback(usUser);
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(parChild,pCb); 
    pCb = MakeJulChoSetCallback(driv,"SMS","","");
    if(pCb == NULL){
        return 0;
    }
    AppendHipadabaCallback(parChild,pCb); 
    AppendHipadabaCallback(parChild,
        MakeHipadabaCallback(JulChoGetCallback,driv,NULL)); 
 
    
    AddHipadabaChild(driv->parNode,child,NULL);
    
    child = MakeHipadabaNode(CH3N,HIPNONE,0); 
    if(child == NULL){
        return 0;
    }  
    if(!ConfigureSingleJulCho(child,driv,"::","::")){
        return 0;
    }
    AddHipadabaChild(driv->parNode,child,NULL);

    child = MakeHipadabaNode(CH4N,HIPNONE,0); 
    if(child == NULL){
        return 0;
    }  
    if(!ConfigureSingleJulCho(child,driv,":::",":")){
        return 0;
    }
    AddHipadabaChild(driv->parNode,child,NULL);

    child = MakeHipadabaNode(CH5N,HIPNONE,0); 
    if(child == NULL){
        return 0;
    }  
    if(!ConfigureSingleJulCho(child,driv,"::::","")){
        return 0;
    }
    AddHipadabaChild(driv->parNode,child,NULL);
    
    return 1;            
}
/*================= actual interface functions ==============================*/
static int JulChoInit(pCodri pDriv){
    pJulCho self = NULL;
    int status;
    
    self = (pJulCho)pDriv->pPrivate;
    status = initRS232(self->controller);
    if(status < 1){
        self->errorCode = status;
    }
    setRS232SendTerminator(self->controller,"$");
    setRS232ReplyTerminator(self->controller,"$");
    setRS232Timeout(self->controller,2000);
    return 1;
}
/*---------------------------------------------------------------------------*/
static int JulChoClose(pCodri pDriv){
    pJulCho self = NULL;
    
    self = (pJulCho)pDriv->pPrivate;
    closeRS232(self->controller);
    return 1;
}
/*---------------------------------------------------------------------------*/
static int JulChoKill(pCodri pDriv){
    pJulCho self = NULL;

    if(pDriv == NULL){
        return 1;
    }
    self = (pJulCho)pDriv->pPrivate;
    JulChoClose(pDriv);
    if(self->controller != NULL){
        KillRS232(self->controller);
        self->controller = NULL;
    }    
    free(self);
    return 1;
}
/*---------------------------------------------------------------------------
 * The set and get routines introduce phase and speed values which map to
 * nomspeed when setting and actspeed when reading. This ugly hack saves me
 * to introduce another drive adapter which set one parameter and reads 
 * another
 *---------------------------------------------------------------------------*/
static int JulChoSetPar2(pCodri pDriv, char *parname, char *pValue){
    pJulCho self = NULL;
    pHdb target = NULL;
    hdbValue v;
    char error[64], *pPtr = NULL;
    int status;
    
    if(strcmp(parname,"master/speed") == 0){
        status = JulChoSetPar2(pDriv,"master/nomspeed", pValue);
        if(status == 1) {
            SicsWait(10);
        }
        return status;
    } else if(strcmp(parname,"master/phase") == 0){
        return JulChoSetPar2(pDriv,"master/nomphase", pValue);
    } else if(strcmp(parname,"snail/phase") == 0){
        return JulChoSetPar2(pDriv,"snail/nomphase", pValue);
    } else if(strcmp(parname,"rabbit/phase") == 0){
        return JulChoSetPar2(pDriv,"rabbit/nomphase", pValue);
    } else if(strcmp(parname, "four/phase") == 0){
        return JulChoSetPar2(pDriv,"four/nomphase", pValue);
    } else if(strcmp(parname,"five/phase") == 0){
        return JulChoSetPar2(pDriv,"five/nomphase", pValue);
    }
    
    self = (pJulCho)pDriv->pPrivate;
    target = GetHipadabaNode(self->parNode,parname);
    if(target == NULL){
        self->errorCode = NOTPAR;
        return 0;
    }
    v.dataType = target->value.dataType;
    if(!readHdbValue(&v,pValue,error,63)){
        self->errorCode = BADTEXT;
        return 0;
    }    
    self->errorCode = 0;
    status = SetHipadabaPar(target,v,NULL);
    if(status == 0 && self->errorCode == 0){
        self->errorCode = status;
        return 0;
    }
    /*
     * The SicsWait is here to allow the chopper to update his status flags.
     * There were occurrences where the chopper was still driving but the 
     * status flag did not reflect this.
     */
    SicsWait(STWAIT);
    self->lastUpdate = 0;
    return status;
}
/*-------------------------------------------------------------------------------*/
static int JulChoSetPar(pCodri pDriv, char *parname, float fValue){
    pJulCho self = NULL;
    pHdb target = NULL;
    hdbValue v;
    char error[64];
    int status;
 
    if(strcmp(parname,"master/speed") == 0){
        status = JulChoSetPar(pDriv,"master/nomspeed", fValue);
        if(status == 1) {
            SicsWait(10);
        }
        return status;
    } else if(strcmp(parname,"master/phase") == 0){
        return JulChoSetPar(pDriv,"master/nomphase", fValue);
    } else if(strcmp(parname,"snail/phase") == 0){
        return JulChoSetPar(pDriv,"snail/nomphase", fValue);
    } else if(strcmp(parname,"rabbit/phase") == 0){
        return JulChoSetPar(pDriv,"rabbit/nomphase", fValue);
    } else if(strcmp(parname, "four/phase") == 0){
        return JulChoSetPar(pDriv,"four/nomphase", fValue);
    } else if(strcmp(parname,"five/phase") == 0){
        return JulChoSetPar(pDriv,"five/nomphase", fValue);
    }
    
    self = (pJulCho)pDriv->pPrivate;
    target = GetHipadabaNode(self->parNode,parname);
    if(target == NULL){
        self->errorCode = NOTPAR;
        return 0;
    }
    v.dataType = target->value.dataType;
    if(v.dataType == HIPINT){
        v.v.intValue = (int)fValue;
    } else {
        v.v.doubleValue = (double)fValue;
    } 
    self->errorCode = 0;
    status = SetHipadabaPar(target,v,NULL);
    if(status == 0 && self->errorCode == 0){
        self->errorCode = status;
        return 0;
    }
    /*
     * The SicsWait is here to allow the chopper to update his status flags.
     * There were occurrences where the chopper was still driving but the 
     * status flag did not reflect this.
     */
    SicsWait(STWAIT);
    self->lastUpdate = 0;
    return status;
}
/*---------------------------------------------------------------------------*/
static int JulChoHalt(pCodri pDriv){
    pJulCho self = NULL;
    
    self = (pJulCho)pDriv->pPrivate;
    self->halt = 1;
    /*
     * empty function on Philips request
     */
    return 1;
}
/*--------------------------------------------------------------------------*/
static int JulChoGetPar(pCodri pDriv, char *parname, 
                         char *pBuffer, int iBufLen){
    pJulCho self = NULL;
    pHdb target = NULL;
    pDynString val = NULL;

    if(strcmp(parname,"master/speed") == 0){
        return JulChoGetPar(pDriv,"master/actspeed", pBuffer,iBufLen);
    } else if(strcmp(parname,"master/phase") == 0){
        return JulChoGetPar(pDriv,"master/actphase", pBuffer,iBufLen);
    } else if(strcmp(parname,"snail/phase") == 0){
        return JulChoGetPar(pDriv,"snail/actphase", pBuffer,iBufLen);
    } else if(strcmp(parname,"rabbit/phase") == 0){
        return JulChoGetPar(pDriv,"rabbit/actphase", pBuffer,iBufLen);
    } else if(strcmp(parname, "four/phase") == 0){
        return JulChoGetPar(pDriv,"four/actphase", pBuffer,iBufLen);
    } else if(strcmp(parname,"five/phase") == 0){
        return JulChoGetPar(pDriv,"five/actphase", pBuffer,iBufLen);
    }

    
    self = (pJulCho)pDriv->pPrivate;
    target = GetHipadabaNode(self->parNode,parname);
    if(target == NULL){
        self->errorCode = NOTPAR;
        return 0;
    }
    if(!UpdateJulChoParameters(self,testParGroup(parname))){
        return 0;
    }
    val = formatValue(target->value, target);
    if(val == NULL){
        self->errorCode = NOMEM;
        return 0;
    }
    strncpy(pBuffer,GetCharArray(val), iBufLen);
    DeleteDynString(val);
    return 1;                            
}
/*---------------------------------------------------------------------------*/
static int JulChoCheckPar(pCodri pDriv, char *parname){
    pJulCho self = NULL;
    int i, status;
    char path[256], reply[256];
    pHdb target = NULL;
    char *chNames[] = {CH1N,
                       CH2N,
                       CH3N,
                       CH4N,
                       CH5N,
                       NULL};

    self = (pJulCho)pDriv->pPrivate;
    
    if(self->halt == 1){
        self->errorCode = HALT;
        return HWFault;
    }
    /* 
     * For the Juelich chopper this means checking the atspeed, atphase
     * flags
     */
    if(!ReadJulChoFlags(self)){
        return HWFault;
    }
    for(i = 0; i < 5; i++){
        snprintf(path,255,"%s/atspeed", chNames[i]);
        target = GetHipadabaNode(self->parNode,path);
        assert(target != NULL);
        if(target->value.v.intValue == 0){
            return HWBusy;
        }
        snprintf(path,255,"%s/atphase",chNames[i]);
        target = GetHipadabaNode(self->parNode,path);
        assert(target != NULL);
        if(target->value.v.intValue == 0){
            return HWBusy;
        }
    }
    status = JulChoTransact(self,"RSC",reply,255);
    if(status < 0){
        self->errorCode = status;
        return HWFault;
    }
/*    fprintf(stdout,"Chopper Flags at finish: %s\n", reply);*/
    return HWIdle;
}
/*---------------------------------------------------------------------------*/
static int JulChoError(pCodri pDriv, int *iCode, char *pError, int iLen){
    pJulCho self = NULL;

    self = (pJulCho)pDriv->pPrivate;

    *iCode = self->errorCode;
    JulChoErrorcodeToString(self->errorCode, pError, iLen);
    return 1;       
}
/*---------------------------------------------------------------------------*/
static int JulChoFix(pCodri pDriv, int  code){
    pJulCho self = NULL;

    self = (pJulCho)pDriv->pPrivate;
    
    switch(code){
        case TIMEOUT:
        case CKERROR:
        case BADERR:
        case BADREPLY:
            return CHREDO;
            break;
        case  NOTCONNECTED:
            if(initRS232(self->controller) == 1){
                return CHREDO;
            } else {
                return CHFAIL;
            }
            break;
        case INCOMPLETE:
        case BADSEND:
        case BADREAD:
            closeRS232(self->controller);
            if(initRS232(self->controller) == 1){
                return CHREDO;
            } else {
                return CHFAIL;
            }
            break;
        default:
            return CHFAIL;
            break;            
    }
}
/*---------------------------------------------------------------------------*/
static pCodri MakeJulChoDriver(char *pHost, int port, pHdb parNode){
    pCodri pDriv = NULL;
    pJulCho self = NULL;
    int i;
    pDynString names = NULL;
    char *chNames[] = {CH1N,
                       CH2N,
                       CH3N,
                       CH4N,
                       CH5N,
                       NULL};
    char path[256], *par = NULL;
    
    pDriv = malloc(sizeof(Codri));
    self = malloc(sizeof(JulCho));
    names = CreateDynString(256,256);
    
    if(pDriv == NULL && self == NULL && names == NULL){
        return NULL;
    }
    memset(pDriv,0,sizeof(Codri));
    memset(self,0,sizeof(JulCho));
    
    self->parNode = parNode;
    self->controller = createRS232(pHost,port);
    if(self->controller == NULL){
       free(self);
       free(pDriv);
       return NULL;
    }
    self->updateIntervall = 10;
    if(!InitJulChoPar(self)){
        free(self);
        free(pDriv);
        return NULL;
    }
    
    pDriv->pPrivate = self;
    
    pDriv->Init      =  JulChoInit;
    pDriv->Close     =  JulChoClose;
    pDriv->Delete    =  JulChoKill;
    pDriv->SetPar    =  JulChoSetPar;
    pDriv->SetPar2   =  JulChoSetPar2;
    pDriv->GetPar    =  JulChoGetPar;
    pDriv->CheckPar  =  JulChoCheckPar;
    pDriv->GetError  =  JulChoError;
    pDriv->TryFixIt  =  JulChoFix;
    pDriv->Halt      =  JulChoHalt;
    
    for(i = 0; i < 5; i++){
        snprintf(path,255,"%s/nomspeed,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/actspeed,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/nomphase,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/actphase,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/gatewidth,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/nomcurrent,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/actcurrent,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/voltage,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/inverter_temperature,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/stator_temperature,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/microok,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/atspeed,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/atphase,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/magneton,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/dcon,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/driveon,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/currentdc,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/lockopen,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/diskopen,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/diskclosed,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/speedoverflow,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/bearingfailed,",chNames[i]);
        DynStringConcat(names,path);    
        snprintf(path,255,"%s/voltagetohigh,",chNames[i]);
        DynStringConcat(names,path);    
    } 
    par = GetCharArray(names);
    par[strlen(par) -1] = '\0';
    pDriv->pParList = strdup(par);
    DeleteDynString(names);
    if(pDriv->pParList == NULL){
        JulChoKill(pDriv);
        free(pDriv);
        return NULL;
    }

    return pDriv;    
}
/*--------------------------------------------------------------------------*/
int JulChoFactory(SConnection *pCon, SicsInterp *pSics, void *pData,
                  int argc, char *argv[]){
      pChoco pNew = NULL;
      pCodri pDriv = NULL;
      pObjectDescriptor pDes = NULL;
      char pBueffel[132];
      int iRet, iPort, iChannel;
      int iSingle = 0;

      if(argc < 4)
      {
         SCWrite(pCon,
            "ERROR: Insufficient number of arguments to MakeJulCho",
                 eError);
         return 0;
      }
    

      /* first try to get everything done */
      pNew = (pChoco)malloc(sizeof(Choco));
      pDes = CreateDescriptor("Chopper");
      pDes->parNode = MakeHipadabaNode(argv[1], HIPNONE,0);
      /* do driver */
      
      pDriv = MakeJulChoDriver(argv[2],atoi(argv[3]),pDes->parNode);
      if(pDriv == NULL){
          sprintf(pBueffel,"ERROR: Failed to initialize JulCho Driver");
        SCWrite(pCon,pBueffel,eError);
        return 0;
      }
      if( (pNew == NULL) || (pDes == NULL) || (pDriv == NULL) )
      {
        SCWrite(pCon,"ERROR: No memory left to create controller",eError);
        return 0;
      }
      pNew->pDes = pDes;
      pNew->pDriv = pDriv;

      /* initialize driver */
      iRet = pDriv->Init(pDriv);
      if(!iRet){
        SCWrite(pCon,"ERROR: Failed to initialize driver",eError);
        KillChoco(pNew);
        return 0;
      }

      /* install as command */
      iRet = AddCommand(pSics, argv[1],ChocoAction,KillChoco,pNew);
      if(!iRet){
        sprintf(pBueffel,"ERROR: duplicate command %s NOT created",
        argv[1]);
        SCWrite(pCon,pBueffel,eError);
        return 0;
      }
      return 1;
}