diff --git a/motorApp/NewportSrc/Socket.cpp b/motorApp/NewportSrc/Socket.cpp new file mode 100755 index 00000000..0a91c568 --- /dev/null +++ b/motorApp/NewportSrc/Socket.cpp @@ -0,0 +1,244 @@ +/* +DESCRIPTION +This module implements a client which periodically +sends a request to the slave spawned by a concurrent +server. This code illustrates how many clients +to be handled in parallel if the server has a +concurrent architecture. +*/ + +/* includes */ + +#ifdef vxWorks +#else +#define TRUE 1 +#define FALSE 0 +typedef int BOOL; +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* defines */ + +#define MAX_MSG_SIZE 80 +#define TIMEOUT 0.5 +#define SIZEBUFFER 256 +#define CONNREFUSED -1 +#define CREATESOCKETFAILED -2 +#define OPTREFUSED -3 + +#define MAX_NB_SOCKETS 100 + +/* typedefs */ + +typedef int SOCK_FD; + +/* global variables */ + +SOCK_FD sockFd[MAX_NB_SOCKETS]; +BOOL UsedSocket[MAX_NB_SOCKETS] = { FALSE }; +double TimeoutSocket[MAX_NB_SOCKETS]; +int ErrorSocket[MAX_NB_SOCKETS]; + + + + +/***************************************************************************************/ +int ConnectToServer(char *Ip_Address, int Ip_Port, double TimeOut) +{ +/* printf("Socket.cpp ConnectToServer: Top/n");*/ + int flag = 1; + u_long srvInet; + struct sockaddr_in srvAddr; + int SocketIndex = 0; + + int status; + char * optval=0; + osiSocklen_t optlen; + status = getsockopt (SocketIndex,IPPROTO_TCP,TCP_NODELAY, optval, &optlen); + + /* Select a free socket */ + while ((UsedSocket[SocketIndex] == TRUE) && (SocketIndex < MAX_NB_SOCKETS)) + { + SocketIndex++; + } + + if (SocketIndex == MAX_NB_SOCKETS) + return -1; + + /* Create socket */ + ErrorSocket[SocketIndex] = 0; + if ((sockFd[SocketIndex] = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0 ) + { + ErrorSocket[SocketIndex] = CREATESOCKETFAILED; + return -1; + } + + /* Convert the server's IP address from ASCII dot notation to */ + /* a network byte-ordered integer */ + srvInet = inet_addr (Ip_Address); + + /* Initialize servers address */ + memset ((char *)&srvAddr, 0, sizeof(srvAddr)); + srvAddr.sin_family = AF_INET; + srvAddr.sin_port = htons (Ip_Port); + srvAddr.sin_addr.s_addr = srvInet; + + if (setsockopt (sockFd[SocketIndex], + IPPROTO_TCP, + TCP_NODELAY, + (char *)&flag, + (int)sizeof(flag)) != 0 ) + { + ErrorSocket[SocketIndex] = OPTREFUSED; + return -1; + } + + /* Connect to server */ + if (connect(sockFd[SocketIndex], (sockaddr *)&srvAddr, sizeof(srvAddr)) < 0) + { + ErrorSocket[SocketIndex] = CONNREFUSED; + return -1; + } + + if (TimeOut > 0) TimeoutSocket[SocketIndex] = TimeOut; + else TimeoutSocket[SocketIndex] = TIMEOUT; + UsedSocket[SocketIndex] = TRUE; + + return SocketIndex; +} + +/***************************************************************************************/ +void SetTCPTimeout(int SocketIndex, double TimeOut) +{ + if ((SocketIndex >= 0) && (SocketIndex < MAX_NB_SOCKETS) && (UsedSocket[SocketIndex] == TRUE)) + { + if (TimeOut > 0) TimeoutSocket[SocketIndex] = TimeOut; + } +} + +/***************************************************************************************/ +void SendAndReceive (int SocketIndex, char *buffer, char *valueRtrn) +{ + char pBuf[SIZEBUFFER]={'\0'}; + int iRvcd=0; + clock_t start, finish; + double timeEllapse = 0.0; + + if ((SocketIndex >= 0) && (SocketIndex < MAX_NB_SOCKETS) && (UsedSocket[SocketIndex] == TRUE)) + { + /* Send String to controller and wait for response */ + + write (sockFd[SocketIndex], buffer, strlen(buffer) + 1); +/* printf("SendAndRecieve after write\n");*/ + /* Read error ? */ + iRvcd = read (sockFd[SocketIndex], pBuf, SIZEBUFFER); + start = clock(); +/* printf("SendAndRecieve after read\n");*/ + + while ((iRvcd <= 0) && (timeEllapse < TimeoutSocket[SocketIndex])) + { + iRvcd = read (sockFd[SocketIndex], pBuf, SIZEBUFFER); + finish = clock(); + timeEllapse = (double)(finish - start) / CLOCKS_PER_SEC; + /* waiting ... */ + } + } + if (iRvcd > 0) pBuf[iRvcd] = '\0'; + strcpy(valueRtrn, pBuf); +} +/***************************************************************************************/ +void SendOnly (int SocketIndex, char *buffer, char *valueRtrn) +{ + char pBuf[SIZEBUFFER]={'\0'}; + int iRvcd=0; + clock_t start, finish; + double timeEllapse = 0.0; + + if ((SocketIndex >= 0) && (SocketIndex < MAX_NB_SOCKETS) && (UsedSocket[SocketIndex] == TRUE)) + { + /* Send String to controller and wait for response */ + + write (sockFd[SocketIndex], buffer, strlen(buffer) + 1); +/* printf("---------------------SendOnly after write\n");*/ + /* Read error ? */ +/* iRvcd = read (sockFd[SocketIndex], pBuf, SIZEBUFFER); + start = clock(); + printf("SendAndRecieve after read\n"); + + while ((iRvcd <= 0) && (timeEllapse < TimeoutSocket[SocketIndex])) + { + iRvcd = read (sockFd[SocketIndex], pBuf, SIZEBUFFER); + finish = clock(); + timeEllapse = (double)(finish - start) / CLOCKS_PER_SEC; + + }*/ + } + /*if (iRvcd > 0) pBuf[iRvcd] = '\0';*/ + pBuf[iRvcd] = '\0'; + strcpy(valueRtrn, pBuf); +} + +/***************************************************************************************/ +void CloseSocket(int SocketIndex) +{ + if ((SocketIndex >= 0) && (SocketIndex < MAX_NB_SOCKETS) && (UsedSocket[SocketIndex] == TRUE)) + { + close (sockFd[SocketIndex]); + TimeoutSocket[SocketIndex] = TIMEOUT; + ErrorSocket[SocketIndex] = 0; + UsedSocket[SocketIndex] = FALSE; + } +} + +/***************************************************************************************/ +void CloseAllSockets(void) +{ + int i; + for (i = 0; i < MAX_NB_SOCKETS; i++) + { + if (UsedSocket[i] == TRUE) + { + close (sockFd[i]); + TimeoutSocket[i] = TIMEOUT; + ErrorSocket[i] = 0; + UsedSocket[i] = FALSE; + } + } +} + +/***************************************************************************************/ +void ResetAllSockets(void) +{ + int i; + for (i = 0; i < MAX_NB_SOCKETS; i++) + { + if (UsedSocket[i] == TRUE) + UsedSocket[i] = FALSE; + } +} + + +/***************************************************************************************/ +char * GetError(int SocketIndex) +{ + if ((SocketIndex >= 0) && (SocketIndex < MAX_NB_SOCKETS) && (UsedSocket[SocketIndex] == TRUE)) + { + switch (ErrorSocket[SocketIndex]) + { + case CONNREFUSED: return("The attempt to connect was rejected."); + case CREATESOCKETFAILED: return("Create Socket failed."); + case OPTREFUSED: return("SetSockOption() Refused."); + } + } + return(""); +} diff --git a/motorApp/NewportSrc/Socket.h b/motorApp/NewportSrc/Socket.h new file mode 100755 index 00000000..5c6699b1 --- /dev/null +++ b/motorApp/NewportSrc/Socket.h @@ -0,0 +1,9 @@ + +int ConnectToServer (char *Ip_Address, int Ip_Port, double Timeout); +void SetTCPTimeout(int SocketIndex, double TimeOut); +void SendAndReceive (int SocketIndex, char *buffer, char *valueRtrn); +void SendOnly (int SocketIndex, char *buffer, char *valueRtrn); +void CloseSocket (int SocketIndex); +void CloseAllSockets (void); +void ResetAllSockets (void); +char * GetError (int SocketIndex); diff --git a/motorApp/NewportSrc/devXPSC8.cc b/motorApp/NewportSrc/devXPSC8.cc new file mode 100755 index 00000000..d0ad48d1 --- /dev/null +++ b/motorApp/NewportSrc/devXPSC8.cc @@ -0,0 +1,437 @@ +/* File: devXPSC8.cc */ + +/* Device Support Routines for motor record for XPS C8 Motor Controller */ +/* + * Original Author: Jon Kelly + * + */ + + +#define VERSION 1.00 + +#include +#include +#include +#include +#include "motorRecord.h" +#include "motor.h" +#include "motordevCom.h" +#include "drvXPSC8.h" + +/*#define DLL _declspec(dllexport)*/ +#include "xps_c8_driver.h" + +#define STATIC static +extern struct driver_table XPSC8_access; + +#define NINT(f) (long)((f)>0 ? (f)+0.5 : (f)-0.5) +#define MIN(a,b) ((a)<(b) ? (a) : (b)) +#define ABS(f) ((f)>0 ? (f) : -(f)) + +#define MOVING 1 + + +#ifdef NODEBUG +#define Debug(L,FMT,V) ; +#else +volatile int devXPSC8Debug = 0; +epicsExportAddress(int, devXPSC8Debug); +/* To make the var available to the shell */ + +#define Debug(L,FMT,V...) { if(L <= devXPSC8Debug) \ + { printf("%s(%d):",__FILE__,__LINE__); \ + printf(FMT,##V); } } +#endif + +/* Debugging levels: + * devXPSC8Debug >= 3 Print new part of command and command string so far + * at the end of XPSC8_build_trans + */ + + +/* ----------------Create the dsets for devXPSC8----------------- */ +STATIC struct driver_table *drvtabptr; +STATIC long XPSC8_init(int); +STATIC long XPSC8_init_record(struct motorRecord *); +STATIC long XPSC8_start_trans(struct motorRecord *); +STATIC RTN_STATUS XPSC8_build_trans(motor_cmnd, double *, struct motorRecord *); +STATIC RTN_STATUS XPSC8_end_trans(struct motorRecord *); + +struct motor_dset devXPSC8 = +{ + {8, NULL, (DEVSUPFUN)XPSC8_init, (DEVSUPFUN)XPSC8_init_record, NULL}, + motor_update_values, + XPSC8_start_trans, + XPSC8_build_trans, + XPSC8_end_trans +}; +epicsExportAddress(dset,devXPSC8); + + +/* --------------------------- program data --------------------- */ +/* This table is used to define the command types */ + +static msg_types XPSC8_table[] = { + MOTION, /* MOVE_ABS */ + MOTION, /* MOVE_REL */ + MOTION, /* HOME_FOR */ + MOTION, /* HOME_REV */ + IMMEDIATE, /* LOAD_POS */ + IMMEDIATE, /* SET_VEL_BASE */ + IMMEDIATE, /* SET_VELOCITY */ + IMMEDIATE, /* SET_ACCEL */ + IMMEDIATE, /* GO */ + IMMEDIATE, /* SET_ENC_RATIO */ + INFO, /* GET_INFO */ + MOVE_TERM, /* STOP_AXIS */ + VELOCITY, /* JOG */ + IMMEDIATE, /* SET_PGAIN */ + IMMEDIATE, /* SET_IGAIN */ + IMMEDIATE, /* SET_DGAIN */ + IMMEDIATE, /* ENABLE_TORQUE */ + IMMEDIATE, /* DISABL_TORQUE */ + IMMEDIATE, /* PRIMITIVE */ + IMMEDIATE, /* SET_HIGH_LIMIT */ + IMMEDIATE /* SET_LOW_LIMIT */ +}; + + +static struct board_stat **XPSC8_cards; + +/* --------------------------- program data --------------------- */ + + + +/* initialize device support for XPSC8 stepper motor */ +STATIC long XPSC8_init(int after) +{ + long rtnval; + + Debug(1, "XPSC8_init, after=%d\n", after); + if (after == 0) { + drvtabptr = &XPSC8_access; + Debug(1, "XPSC8_init, calling driver initialization\n"); + (drvtabptr->init)(); + } + + rtnval = motor_init_com(after, *drvtabptr->cardcnt_ptr, drvtabptr, + &XPSC8_cards); + Debug(1, "XPSC8_init, end of function\n"); + return(rtnval); +} + + +/* initialize a record instance */ +STATIC long XPSC8_init_record(struct motorRecord *mr) +{ + long rtnval; + struct motor_trans *trans; + struct mess_node *motor_call; + struct controller *brdptr; + struct XPSC8controller *control; + struct XPSC8axis *cntrl; + int card, signal; + + Debug(1, "--------XPSC8_init_record \n"); + rtnval = motor_init_record_com(mr, *drvtabptr->cardcnt_ptr, + drvtabptr, XPSC8_cards); + /* We have a logic problem here. motor_init has read in the motor + * position in engineering units, but it did not yet know the resolution + * to convert to steps. It thus did a divide by zero. + * We have to wait till after calling + * motor_init_record_com for mr->dpvt to be initialized, and then set + * the rmp field of the record again */ + trans = (struct motor_trans *) mr->dpvt; + motor_call = &(trans->motor_call); + card = mr->out.value.vmeio.card; + signal = mr->out.value.vmeio.signal; + brdptr = (*trans->tabptr->card_array)[card]; + control = (struct XPSC8controller *) brdptr->DevicePrivate; + cntrl = (struct XPSC8axis *)&control->axis[signal]; + cntrl->resolution = mr->mres; /* Set the motor resolution */ + mr->rmp = NINT(cntrl->currentposition[1] / cntrl->resolution); + Debug(1, "XPSC8_init_record: card=%d, signal=%d, currentposition[1]=%f" + " resolution=%f, mr->rmp=%d\n", + card, signal, cntrl->currentposition[1], cntrl->resolution, mr->rmp); + return(rtnval); +} + + +/* start building a transaction */ +STATIC long XPSC8_start_trans(struct motorRecord *mr) +{ + Debug(1, "--------XPSC8_start_trans\n"); + long rtnval; + rtnval = motor_start_trans_com(mr, XPSC8_cards); + return(rtnval); +} + + +/* end building a transaction */ +STATIC RTN_STATUS XPSC8_end_trans(struct motorRecord *mr) +{ + Debug(1, "--------XPSC8_end_trans\n"); + RTN_STATUS rtnval; + rtnval = motor_end_trans_com(mr, drvtabptr); + return(rtnval); + +} + + +/* add a part to the transaction */ +STATIC RTN_STATUS XPSC8_build_trans(motor_cmnd command, double *parms, struct motorRecord *mr) +{ + struct motor_trans *trans = (struct motor_trans *) mr->dpvt; + struct mess_node *motor_call; + struct controller *brdptr; + struct XPSC8controller *control; + struct XPSC8axis *cntrl; + double dval=0.,resolution,steps; + int ival=0; + RTN_STATUS rtnval=OK; + int card, signal; + + int positioner, status; + + positioner = 1; /* Means only move one axis at a time */ + if (parms != NULL){ + dval = parms[0]; /* I assume this is the record DVAL which you set*/ + /* to move e.g. dval = 10mm and command = MOVE_ABS*/ + ival = NINT(parms[0]); + } + + motor_call = &(trans->motor_call); + card = motor_call->card; + signal = motor_call->signal; + brdptr = (*trans->tabptr->card_array)[card]; + + Debug(11, "XPSC8_build_trans: After brdptr command\n"); + + if (brdptr == NULL) + return(rtnval = ERROR); + + control = (struct XPSC8controller *) brdptr->DevicePrivate; + cntrl = (struct XPSC8axis *)&control->axis[signal]; + + resolution = cntrl->resolution; + steps = resolution * dval; + +/* mr->dllm = cntrl->minlimit;*/ /* set the epics limits to the XPS limits */ +/* mr->dhlm = cntrl->maxlimit; */ + + Debug(1, "XPSC8_build_trans: card=%d, signal=%d, command=%d, ival=%d" + " dval=%f, steps=%f\n", + card, signal, command, ival, dval, steps); + + Debug(1, "XPSC8_build_trans: resolution=%f\n",resolution); + if (XPSC8_table[command] > motor_call->type) + motor_call->type = XPSC8_table[command]; + Debug(11, "XPSC8_build_trans: After cntrl command\n"); + if (trans->state != BUILD_STATE) + return(rtnval = ERROR); + Debug(11, "XPSC8_build_trans: After cntrl command\n"); + /* Take a lock so that only 1 thread can be talking to the XPSC8 at + * once. I don't know if this is needed? */ + epicsMutexLock(control->XPSC8Lock); + + /* No need to deal with initialization, premove or postmove strings, + XPSC8 does not support */ + + Debug(1, "build_trans: Top Of Switch command=%d, cntrl->moving=%d" + " GStat=%d-\n", command,cntrl->moving,cntrl->groupstatus); + + switch (command) { + case MOVE_ABS:/* command 0*/ + + Debug(1, "XPSC8_build_trans: command=%d, Move_ABS moving=%d steps=%f\n", + command,cntrl->moving, steps); + + if ((cntrl->moving) == MOVING) { + printf("--STILL MOVING--\n"); + goto done; + } /* This is set in drvXPSC8.cc*/ + + Debug(11, "Move_ABS socket=%d posiname=%s posit=%d dval=%f\n", + cntrl->socket, cntrl->positionername, positioner, dval); + epicsThreadSleep(0.1); + + status = GroupMoveAbsolute(cntrl->socket, cntrl->positionername, + positioner, &steps); + if (status != 0) { + printf(" Error performing GroupMoveAbsolute\n"); + } + + Debug(1, "--After GroupMoveAbsolute command=%d,Move_ABS moving=%d \n", + command,cntrl->moving); + + break; + + case MOVE_REL: + /* Using the SGamma setings in stages.ini */ + if (cntrl->moving == MOVING) goto done; + /* This is set in drvXPSC8.cc*/ + status = GroupMoveRelative(cntrl->socket, cntrl->positionername, + positioner, &steps); + if (status != 0) printf(" Error performing GroupMoveRelative\n"); + break; + + case HOME_FOR: + case HOME_REV: + /* If motion has been killed the group will need to be initialized*/ + /* and homed before the motors can be driven again */ + if (cntrl->groupstatus < 10 ) { + /* ie not initialized state!*/ + status = GroupInitialize(cntrl->pollsocket,cntrl->groupname); + if (status != 0) { + printf("HOME Command Error performing GroupInitialise\n"); + } + status = GroupStatusGet(cntrl->pollsocket, cntrl->groupname, + &cntrl->groupstatus); + if (status != 0) { + printf(" Error performing GroupStatusGet\n"); + } + Debug(1, "XPSC8_build_trans:****** Perform GroupInitialize\n"); + status = GroupHomeSearch(cntrl->socket,cntrl->groupname); + if (status != 0) { + printf(" Error performing GroupHomeSearch\n"); + } + Debug(1, "XPSC8_build_trans:******* Perform GroupHomeSearch\n"); + + break; + } + + status = GroupKill(cntrl->pollsocket,cntrl->groupname); + if (status != 0) { + printf(" Error performing GroupKill\n"); + } + + status = GroupInitialize(cntrl->pollsocket,cntrl->groupname); + if (status != 0) { + printf("HOME Command Error performing GroupInitialise\n"); + } + + + status = GroupStatusGet(cntrl->pollsocket, cntrl->groupname, + &cntrl->groupstatus); + if (status != 0) { + printf(" Error performing GroupStatusGet\n"); + } + Debug(1, "XPSC8_build_trans:****** Perform GroupInitialize\n"); + + status = GroupHomeSearch(cntrl->socket,cntrl->groupname); + if (status != 0) { + printf(" Error performing GroupHomeSearch\n"); + } + Debug(1, "XPSC8_build_trans:******* Perform GroupHomeSearch\n"); + + /*}*/ + + /* if (cntrl->groupstatus == NOTREF ){ */ + /* you must kill a group before homing*/ + /*}*/ + break; + + case LOAD_POS: + /* command 4 I assume it means just update the position value? */ + /*status = GroupPositionCurrentGet(cntrl->socket, + cntrl->positionername, + positioner, + &cntrl->currentposition[1]); + if (status != 0) + printf(" Error performing GroupPositionCurrentGet Load Pos\n");*/ + break; + + case SET_VEL_BASE: + /* The XPS does not have a different Base velocity!!!*/ + break; + case SET_VELOCITY: + /* The XPS does not have a different Base velocity!!!!! + So I perform the same operation for VEL_BASE and VEL*/ + + status = PositionerSGammaParametersSet(cntrl->pollsocket, + cntrl->positionername, steps, + cntrl->accel, + cntrl->minjerktime, + cntrl->maxjerktime); + if (status != 0) + printf(" Error performing PositionerSGammaParameters Set Vel\n"); + else cntrl->velocity = steps; + break; + + case SET_ACCEL: /* command 7 */ + status = PositionerSGammaParametersSet(cntrl->pollsocket, + cntrl->positionername, + cntrl->velocity, + steps, cntrl->minjerktime, + cntrl->maxjerktime); + if (status != 0) + printf(" Error performing PositionerSGammaParameters Set Accel\n"); + else cntrl->accel = steps; + break; + + case GO: + break; + + case SET_ENC_RATIO: /* These must be set in the Stages.ini file */ + break; + + case GET_INFO: /* Again I don't know what this is intended to do? */ + break; + + case STOP_AXIS: + /* The whole group must stop, not just 1 axis */ + if (cntrl->groupstatus > 42) { + /* Then the group is moving! */ + status = GroupMoveAbort(cntrl->pollsocket,cntrl->groupname); + if (status != 0) printf(" Error performing GroupMoveAbort(\n"); + } + break; + + case JOG: + /* I need more commandds to impliment this i.e. enable/disable + set velocity and acceleration */ + break; + + case SET_PGAIN: + case SET_IGAIN: + case SET_DGAIN: + /* These can be implimented but there are so many variables */ + /* It makes sense to do it in the stages.ini file */ + case ENABLE_TORQUE: + case DISABL_TORQUE: + /* The XPSC8 does not support gain or torque commands */ + break; + + case SET_HIGH_LIMIT: + Debug(1, "XPSC8_build_trans highlimit: socket=%d, posname=%s, " + "minlim=%f, steps=%f\n", + cntrl->socket, cntrl->positionername, cntrl->minlimit, steps); + + status = PositionerUserTravelLimitsSet(cntrl->pollsocket, + cntrl->positionername, + cntrl->minlimit, steps); + if (status != 0) + printf(" Error performing PositionerUserTravelLimitsGet " + " Max Limit status=%d\n",status); + else cntrl->maxlimit = steps; + break; + + case SET_LOW_LIMIT: + status = PositionerUserTravelLimitsSet(cntrl->pollsocket, + cntrl->positionername, + steps, cntrl->maxlimit); + if (status != 0) + printf("Error performing PositionerUserTravelLimitsGet Min Limit\n"); + else cntrl->minlimit = steps; + break; + + default: + rtnval = ERROR; + } + +done: + /* Free the lock */ + epicsMutexUnlock(control->XPSC8Lock); + Debug(1, "End Of Build_trans after Switch\n"); + return (rtnval); +} diff --git a/motorApp/NewportSrc/drvXPSC8.cc b/motorApp/NewportSrc/drvXPSC8.cc new file mode 100755 index 00000000..683d80d5 --- /dev/null +++ b/motorApp/NewportSrc/drvXPSC8.cc @@ -0,0 +1,699 @@ +/* + * drvXPSC8.cc + * Motor record driver level support for Newport XPSC8 motor controller. + * + * Original Author: Mark Rivers + * Date: 10-May-2000 + * + * Modification Log: + * ----------------- + + */ + +#include +#include +#include +#include +#include +#include +#include "motor.h" +#include "drvXPSC8.h" + +#include "xps_c8_driver.h" + +#define STATIC static + +/*----------------debugging-----------------*/ +#ifdef NODEBUG +#define Debug(l, f, args...); +#else +/*#define Debug(L,FMT,V...) { if(L <= drvXPSC8Debug) \ + { printf("%s(%d):",__FILE__,__LINE__); \ + printf(FMT,##V); } }*/ + +int drvXPSC8Debug = 0; +epicsExportAddress(int, drvXPSC8Debug); +/* To make the var available to the shell */ +#define Debug(l, f, args...) { if(l<=drvXPSC8Debug) printf(f,## args); } +#endif + +/* --- Local data. --- */ +int XPSC8_num_cards = 0; + +/* Local data required for every driver; see "motordrvComCode.h" */ +#include "motordrvComCode.h" + +/* Why are not all the functions declared here? */ + +/*----------------functions-----------------*/ +STATIC int recv_mess(int, char *, int); +STATIC RTN_STATUS send_mess(int card, const char *com, char c); +STATIC void start_status(int card); +/*STATIC void XPSC8Status(int card);*/ +STATIC int set_status(int card, int signal); +static long report(int level); +static long init(); +STATIC int motor_init(); +STATIC void query_done(int, int, struct mess_node *); +STATIC void readXPSC8Status(int card); + +/*----------------functions-----------------*/ + +struct driver_table XPSC8_access = +{ + motor_init, + motor_send, + motor_free, + motor_card_info, + motor_axis_info, + &mess_queue, + &queue_lock, + &free_list, + &freelist_lock, + &motor_sem, + &motor_state, + &total_cards, + &any_motor_in_motion, + send_mess, + recv_mess, + set_status, + query_done, + start_status, + &initialized +}; + + +struct +{ + long number; +#ifdef __cplusplus + long (*report) (int); + long (*init) (void); +#else + DRVSUPFUN report; + DRVSUPFUN init; +#endif +} drvXPSC8 = {2, report, init}; + +epicsExportAddress(drvet, drvXPSC8); + +/* I don't know where the XPSC8_access is set?*/ +STATIC struct thread_args targs = {SCAN_RATE, &XPSC8_access}; + +/********************************************************* + * Print out driver status report + *********************************************************/ + +static long report(int level) /*########## XPSC8 Version */ +{ + int card; + + if (XPSC8_num_cards <=0) + printf(" No XPSC8 controllers configured.\n"); + else { + for (card = 0; card < XPSC8_num_cards; card++) { + struct controller *brdptr = motor_state[card]; + if (brdptr == NULL) + printf(" XPSC8 controller %d connection failed.\n", card); + else { + struct XPSC8controller *control; + + control = (struct XPSC8controller *) brdptr->DevicePrivate; + printf(" XPSC8 driver %d, axis:%s \n", + card, brdptr->ident); + } + } + } + return (0); +} + + +static long init() +{ + if (XPSC8_num_cards <= 0) + { + Debug(1, "init(): XPSC8 driver disabled. XPSC8etup() missing from startup script.\n"); + } + return ((long) 0); +} + +STATIC void query_done(int card, int axis, struct mess_node *nodeptr) +{ +} + +/********************************************************* + * Read the status and position of all motors on a card + * start_status(int card) + * if card == -1 then start all cards + *********************************************************/ + +STATIC void start_status(int card) +{ + int itera; + + Debug(2, "start_status: card=%d total_cards=%d\n", card,total_cards); + if (card >= 0) { + readXPSC8Status(card); + } else { + for (itera = 0; itera < total_cards; itera++) { + if (motor_state[itera]) readXPSC8Status(itera); + } + } +} + +/***************************************************************** + * Read in the motion parameters such as velocity, Accel, Position etc + *****************************************************************/ + +STATIC void readXPSC8Status(int card) +{ + struct XPSC8controller *control = + (struct XPSC8controller *) motor_state[card]->DevicePrivate; + struct XPSC8axis *cntrl; + int status,statuserror; + int XPSC8_num_axes; + int positioner,i; /* this = 1 because we are talking to 1 axis at a time */ + + struct mess_node *nodeptr; /* These are to print the DONE flag */ + register struct mess_info *motor_info; + msta_field statusflags; + + positioner = 1; + statuserror = 0; /* this = 1 if an error occurs */ + XPSC8_num_axes = motor_state[card]->total_axis; + + Debug(2, "XPSC8:readXPSC8Status card=%d num_axes=%d\n",card,XPSC8_num_axes); + + /* Take a lock so that only 1 thread can be talking to the Neport XPSC8 + */ + epicsMutexLock(control->XPSC8Lock); + + for (i=0; imotor_info[i]); /*To print DONE flag*/ + nodeptr = motor_info->motor_motion; + statusflags.All = motor_info->status.All; + + Debug(9, "XPSC8:readXPSC8Status RA_DONE=%d, RA_MOVING=%d, " + "RA_PROBLEM=%d\n", + statusflags.Bits.RA_DONE, statusflags.Bits.RA_MOVING, + statusflags.Bits.RA_PROBLEM); + + control = (struct XPSC8controller *) motor_state[card]->DevicePrivate; + cntrl = (struct XPSC8axis *)&control->axis[i]; + + Debug(2, "XPSC8:readXPSC8Status card=%d axis=%d sock=%d gp=%s\n",card,i, + cntrl->socket,cntrl->groupname); + + /* Where I have used "&" the func requires an pointer */ + status = GroupStatusGet(cntrl->pollsocket, cntrl->groupname, + &cntrl->groupstatus); + if (status != 0) { + printf(" Error performing GroupStatusGet status=%d\n", status); + statuserror =1; + } + + status = PositionerSGammaParametersGet(cntrl->pollsocket, + cntrl->positionername, + &cntrl->velocity, + &cntrl->accel, + &cntrl->minjerktime, + &cntrl->maxjerktime); + if (status != 0) { + printf(" Error performing PositionerSGammaParametersGet\n"); + statuserror =1; + } + + /* The jog function is not enabled*/ +/* + status = GroupJogParametersGet(cntrl->pollsocket, + cntrl->groupname, + positioner, + &cntrl->jogvelocity, + &cntrl->jogaccel); + if (status != 0) { + printf(" Error performing GroupJogParametersGet\n"); + statuserror =1; + } +*/ + + + status = GroupPositionCurrentGet(cntrl->pollsocket, + cntrl->positionername, + positioner, + &cntrl->currentposition[1]); + if (status != 0) { + printf(" Error performing GroupPositionCurrentGet\n"); + statuserror =1; + } + + + status = GroupPositionTargetGet(cntrl->pollsocket, + cntrl->positionername, + positioner, + &cntrl->targetposition[1]); + if (status != 0) { + printf(" Error performing GroupPositionTargetGet\n"); + statuserror =1; + } + + + status = GroupPositionSetpointGet(cntrl->pollsocket, + cntrl->positionername, + positioner, + &cntrl->setpointposition[1]); + if (status != 0) { + printf(" Error performing GroupPositionSetpointGet\n"); + statuserror =1; + } + + status = PositionerErrorGet(cntrl->pollsocket, + cntrl->positionername, + &cntrl->positionererror); + if (status != 0) { + printf(" Error performing PositionerErrorGet\n"); + statuserror =1; + } + + /* We probably don't need to poll this because the limits are set to + * the database values on startup*/ + + status = PositionerUserTravelLimitsGet(cntrl->pollsocket, + cntrl->positionername, + &cntrl->minlimit, + &cntrl->maxlimit); + if (status != 0) { + printf(" Error performing PositionerUserTravelLimitsGet\n"); + statuserror =1; + } + + Debug(11, "readXPSC8Status, socket=%d, groupname=%s, minlim=%f\n", + cntrl->socket,cntrl->groupname,cntrl->minlimit); + + if (status == 1) + cntrl->status = XPSC8_COMM_ERR; /* This is checked in set_status */ + else + cntrl->status = OK; + } + + /* Free the lock */ + epicsMutexUnlock(control->XPSC8Lock); +} + +/************************************************************** + * Parse status and position for a card and signal + * set_status() + ************************************************************/ + +STATIC int set_status(int card, int signal) +{ + struct XPSC8controller *control; + struct XPSC8axis *cntrl; + struct mess_node *nodeptr; + register struct mess_info *motor_info; + + int positionererror; + int rtn_state, groupstatus; + double motorData, pos,resolution; + bool ls_active = false; + msta_field status; + + control = (struct XPSC8controller *) motor_state[card]->DevicePrivate; + cntrl = (struct XPSC8axis *)&control->axis[signal]; + + resolution = cntrl->resolution; + motor_info = &(motor_state[card]->motor_info[signal]); + nodeptr = motor_info->motor_motion; + status.All = motor_info->status.All; + + /* Lock access to global data structure */ + epicsMutexLock(control->XPSC8Lock); + + Debug(2, "XPSC8:set_status entry: card=%d, signal=%d\n", card, signal); + + /* Parse the error and position values read within the readXPSC8Status + function */ + positionererror = cntrl->positionererror; + pos = cntrl->currentposition[1]; + groupstatus = cntrl->groupstatus; + Debug(2, "XPSC8:set_status entry: positionererror=%d, pos=%f," + " resolution=%f\n", + positionererror, pos, resolution); + Debug(11, "XPSC8:set_status entry: pos0=%f, pos1=%f\n", + cntrl->currentposition[0], cntrl->currentposition[1]); + + if (cntrl->velocity >= 0) + status.Bits.RA_DIRECTION = 1; + else + status.Bits.RA_DIRECTION=0; + + if (groupstatus > 9 && groupstatus < 20) { + /* These states mean ready from move/home/jog etc*/ + status.Bits.RA_DONE=1; /* 1 means cd ready */ + Debug(2, "Set_status: Done -->groupstatus=%d\n", groupstatus); + } else { + status.Bits.RA_DONE=0; + Debug(2, "Set_status: Not Done -->groupstatus=%d\n", groupstatus); + } + status.Bits.RA_PLUS_LS=0; + status.Bits.RA_MINUS_LS=0; + + cntrl->moving = 0 ; /* not moving */ + + if (groupstatus > 42 && groupstatus < 49) { + /* These states mean it is moving/homeing/jogging etc*/ + cntrl->moving = 1; + } + + /* These are hard limits */ + if (positionererror & XPSC8_END_OF_RUN_MINUS ) { + /* I am unsure of the use of & !!*/ + status.Bits.RA_MINUS_LS=1; /* defined in drvXPSC8.h */ + ls_active = true; + } + + if (positionererror & XPSC8_END_OF_RUN_PLUS ) { + status.Bits.RA_PLUS_LS=1; + ls_active = true; + } + + status.Bits.RA_HOME=0; + if (groupstatus == 11) status.Bits.RA_HOME=1; /* ready from home state */ + + status.Bits.EA_POSITION=0; /* position maintenence disabled */ + + /* encoder status */ + status.Bits.EA_SLIP=0; + status.Bits.EA_SLIP_STALL=0; + status.Bits.EA_HOME=0; + + /* Motor position */ + motorData = pos / resolution; + + if (motorData == motor_info->position) + motor_info->no_motion_count++; + else + { + motor_info->position = NINT(motorData); + if (motor_state[card]->motor_info[signal].encoder_present == YES) + motor_info->encoder_position = (int32_t) motorData; + else + motor_info->encoder_position = 0; + + motor_info->no_motion_count = 0; + } + + status.Bits.RA_PROBLEM=0; + + Debug(11, "--------above inisialisation test \n"); + if (groupstatus < 9 || (groupstatus > 19 && groupstatus < 43)) { + /* not initialized or disabled*/ + /* Set the Hard limits To show that it is unable to move */ + status.Bits.RA_MINUS_LS=1; + status.Bits.RA_PLUS_LS=1; + status.Bits.RA_PROBLEM=1; /*This variable is to do with polling*/ + Debug(1, "--------Set Status Not initialised state! \n"); + + } + + motor_info->velocity = (int)cntrl->velocity; + /* I don't know what this is used for */ + +/* if (status.Bits.RA_DIRECTION==0) + motor_info->velocity *= -1;*/ + + rtn_state = (!motor_info->no_motion_count || ls_active == true || + (status.Bits.RA_DONE | status.Bits.RA_PROBLEM)) ? 1 : 0; + + Debug(1, "--------set_status rtn_state=%d \n",rtn_state); + + + if (cntrl->status == XPSC8_COMM_ERR) + /* I defined this to be -1! */ + status.Bits.CNTRL_COMM_ERR=1; + else + status.Bits.CNTRL_COMM_ERR=0; + + /* Free the lock */ + epicsMutexUnlock(control->XPSC8Lock); + motor_info->status.All = status.All; + return(rtn_state); +} + + +/*****************************************************/ +/* send a message to the XPS board */ +/* send_mess() */ +/*****************************************************/ +STATIC RTN_STATUS send_mess(int card, char const *com, char inchar) +{ + /* This is a no-op for the XPS, but must be present */ + return (OK); +} + + +/*****************************************************/ +/* receive a message from the XPS board */ +/* recv_mess() */ +/*****************************************************/ +STATIC int recv_mess(int card, char *com, int flag) +{ + /* This is a no-op for the XPS, but must be present */ + /* Set the returned message to a null string */ + *com = '\0'; + return (0); +} + + + +/*****************************************************/ +/* Setup system configuration */ +/* XPSC8Setup() */ +/*****************************************************/ +RTN_STATUS XPSC8Setup(int num_cards, /* number of controllers in system. */ + int scan_rate) /* I think this is for the epicsthread */ +{ + Debug(1, "XPSC8Setup: Controllers=%d Scan Rate=%d\n",num_cards,scan_rate); + int itera; + if (num_cards > XPSC8_NUM_CHANNELS) + printf(" Error in setup too many channels\n"); + + if (num_cards < 1) + XPSC8_num_cards = 1; + else + XPSC8_num_cards = num_cards; + +/* Set motor polling task rate */ + if (scan_rate >= 1 && scan_rate <= 60) + targs.motor_scan_rate = scan_rate; + else + targs.motor_scan_rate = SCAN_RATE; + + /* Allocate space for pointers to motor_state structures. */ + motor_state = (struct controller **) malloc(XPSC8_num_cards * + sizeof(struct controller *)); + + for (itera = 0; itera < XPSC8_num_cards; itera++) + motor_state[itera] = (struct controller *) NULL; + + return (OK); +} + + +/*****************************************************/ +/* Configure a Newport XPS controller one command */ +/* For each controller */ +/* XPSC8Config() */ +/*****************************************************/ +RTN_STATUS XPSC8Config(int card, /* Controller number */ + const char *ip, /* XPS IP address*/ + int port, /* This may be 5001 */ + int totalaxes) /* Number of axis/positioners used*/ + +{ + struct XPSC8controller *control; + struct XPSC8axis *cntrl; + int statuserror, status, socket, pollsocket, axis; + char *ipchar, List[1000]; + statuserror = 0; + status = 0; + ipchar = (char *)ip; + socket = 0; + pollsocket = 0; + + + Debug(1, "XPSC8Config: IP=%s, Port=%d, Card=%d, totalaxes=%d\n", + ipchar, port, card, totalaxes); + + if (totalaxes < 0 || totalaxes > XPSC8_NUM_CHANNELS) {return (ERROR);} + + motor_state[card] = (struct controller *) calloc(1, + sizeof(struct controller)); + motor_state[card]->DevicePrivate = calloc(1, + sizeof(struct XPSC8controller)); + control = (struct XPSC8controller *) motor_state[card]->DevicePrivate; + + motor_state[card]->total_axis = totalaxes; + + + + for (axis=0; axisaxis[axis]; + Debug(11, "XPSC8Config: axis=%d, cntrl=%p\n", axis, cntrl); + + cntrl->pollsocket = pollsocket; + cntrl->socket = socket; + cntrl->ip = epicsStrDup(ip); + + + Debug(1, "XPSC8Config: Socket=%d, PollSock=%d, ip=%s, port=%d," + " axis=%d controller=%d\n", + cntrl->socket,cntrl->pollsocket,ip,port,axis,card); + } + Debug(11, "XPSC8Config: Above OjectsListGet\n"); + status = ObjectsListGet(socket, List); + if (status != 0) + printf(" Error performing Object List Get\n"); + else + printf("Start of Object List From Controller: %.40s\n",List); + + Debug(11, "XPSC8Config: End\n"); + return (OK); +} + +/*********************************************************/ +/* Pass the group and positioner names */ +/* Call this for each axis */ +/* */ +/*********************************************************/ +RTN_STATUS XPSC8NameConfig(int card, /*specify which controller 0-up*/ + int axis, /*axis number 0-7*/ + const char *gpname, /*group name e.g. Diffractometer */ + const char *posname) /*positioner name e.g. Diffractometer.Phi*/ + +{ + struct XPSC8controller *control; + struct XPSC8axis *cntrl; + + Debug(1, "XPSC8NameConfig: card=%d axis=%d, group=%s, positioner=%s\n", + card, axis, gpname, posname); + + control = (struct XPSC8controller *) motor_state[card]->DevicePrivate; + cntrl = (struct XPSC8axis *)&control->axis[axis]; + + cntrl->groupname = epicsStrDup(gpname); + cntrl->positionername = epicsStrDup(posname); + + return (OK); +} + +/*****************************************************/ +/* initialize all software and hardware */ +/* This is called from the init() */ +/* motor_init() */ +/*****************************************************/ +STATIC int motor_init() +{ + + struct controller *brdptr; + struct XPSC8controller *control; + struct XPSC8axis *cntrl; + int card_index, motor_index; + int status, totalaxes; + + bool errind; + + initialized = true; /* Indicate that driver is initialized. */ + + /* Check for setup */ + Debug(1, "XPSC8:motor_init: num_cards=%d\n", XPSC8_num_cards); + if (XPSC8_num_cards <= 0){ + printf("Error num_cards <=0"); + return (ERROR); + } + + for (card_index = 0; card_index < XPSC8_num_cards; card_index++) { + totalaxes = motor_state[card_index]->total_axis; + Debug(5, "XPSC8:motor_init: Card init loop card_index=%d\n",card_index); + brdptr = motor_state[card_index]; + total_cards = card_index + 1; + Debug(5, "XPSC8:motor_init: Above control def card_index=%d\n", + card_index); + control = (struct XPSC8controller *) brdptr->DevicePrivate; + + cntrl = (struct XPSC8axis *)&control->axis[0]; + /* Just for the test below!*/ + + control->XPSC8Lock = epicsMutexCreate(); + errind = false; + + /* just to test status, 0 means the call worked*/ + status = GroupStatusGet(cntrl->socket,cntrl->groupname, + &cntrl->groupstatus); + if (status !=0) errind = true; + Debug(5, "XPSC8:motor_init: card_index=%d, errind=%d\n", + card_index, errind); + + if (errind == false) { + brdptr->localaddr = (char *) NULL; + brdptr->motor_in_motion = 0; + + /*brdptr->total_axis = XPSC8_NUM_CHANNELS;*/ + /* I have set this to be the no. used inConfig*/ + + for (motor_index = 0; motor_indexmotor_info[motor_index].motor_motion = NULL; + } + + strcpy(brdptr->ident, "XPS_C8_controller"); + + start_status(card_index); + /*Read in all the parameters vel/accel ect */ + + Debug(5, "XPSC8:motor_init: called start_status OK\n"); + for (motor_index = 0; motor_index < totalaxes; motor_index++) { + struct mess_info *motor_info = &brdptr->motor_info[motor_index]; + motor_info->status.All = 0; + motor_info->no_motion_count = 0; + motor_info->encoder_position = 0; + motor_info->position = 0; + /* Read status of each motor */ + Debug(5, " XPSC8:motor_init: calling set_status for motor %d\n", + motor_index); + set_status(card_index, motor_index); + } + } + else + motor_state[card_index] = (struct controller *) NULL; + } + Debug(5, "XPSC8:motor_init: done with start_status and set_status\n"); + + any_motor_in_motion = 0; + + mess_queue.head = (struct mess_node *) NULL; + mess_queue.tail = (struct mess_node *) NULL; + + free_list.head = (struct mess_node *) NULL; + free_list.tail = (struct mess_node *) NULL; + + Debug(5, "XPSC8:motor_init: spawning XPSC8_motor task\n"); + + epicsThreadCreate((char *) "XPSC8_motor", 64, 5000, + (EPICSTHREADFUNC) motor_task, (void *) &targs); + + return (OK); +} diff --git a/motorApp/NewportSrc/drvXPSC8.h b/motorApp/NewportSrc/drvXPSC8.h new file mode 100755 index 00000000..65123b73 --- /dev/null +++ b/motorApp/NewportSrc/drvXPSC8.h @@ -0,0 +1,58 @@ +/* File: drvXPSC8.h */ + +/* Device Driver Support definitions for motor + * + * Original Author: Jon Kelly + * + */ + +#ifndef INCdrvXPSC8h +#define INCdrvXPSC8h 1 + +#include "motordrvCom.h" + +#define XPSC8_END_OF_RUN_MINUS 0x80000100 +#define XPSC8_END_OF_RUN_PLUS 0x80000200 +#define XPSC8_NUM_CHANNELS 8 +#define XPSC8_COMM_ERR -1 +#define TIMEOUT 1 +#define NOTREF 42 + +/*------ This defines the XPSC8 specific property structure */ +struct XPSC8axis +{ + int socket; + int pollsocket; /* This is the same for all motors to poll!*/ + double currentposition[1]; /* the XPS commands want an array */ + double setpointposition[1]; + double targetposition[1]; + double velocity; + double accel; + double minjerktime; /* for the SGamma function */ + double maxjerktime; + double jogvelocity; + double jogaccel; + double maxlimit; + double minlimit; + double resolution; + + char *ip; + char *positionername; /* read in using NameConfig*/ + char *groupname; + int groupstatus; + int positionererror; + int moving; /* 1 = moving! */ + int status; /* Included to fit in with the camac driver template + Not a value from the XPS controller!*/ + +}; + +struct XPSC8controller{ + epicsMutexId XPSC8Lock; + struct XPSC8axis axis[XPSC8_NUM_CHANNELS]; + }; + +/* Global function, used by both driver and device support */ + + +#endif /* INCdrvXPSC8h */ diff --git a/motorApp/NewportSrc/xps_c8_driver.cpp b/motorApp/NewportSrc/xps_c8_driver.cpp new file mode 100755 index 00000000..c6d64d4b --- /dev/null +++ b/motorApp/NewportSrc/xps_c8_driver.cpp @@ -0,0 +1,4025 @@ +//////////////////////////////////////////////////////////////////// +// Created source file api.cpp for API description +// + + +#include /* Added by JHK */ +#include + + +#include +#include +#include +#include "Socket.h" +#define DLL _declspec(dllexport) +#include "xps_c8_driver.h" /* Renamed by JHK */ +#define SIZE_BUFFER 500 + +#define SIZE_NAME 100 + + +#ifdef __cplusplus +extern "C" +{ +#endif + + +#define DLL_VERSION "Library version for XPS-C8 Firmware V1.0.1" + +/***********************************************************************/ +int __stdcall TCP_ConnectToServer(char *Ip_Address, int Ip_Port, double TimeOut) +{ +/* printf("xps_c8_driver.cpp ConnectToServer:/n");*/ + return (ConnectToServer(Ip_Address, Ip_Port, TimeOut)); +} +/***********************************************************************/ +void __stdcall TCP_SetTimeout(int SocketIndex, double Timeout) +{ + SetTCPTimeout(SocketIndex, Timeout); +} +/***********************************************************************/ +void __stdcall TCP_CloseSocket(int SocketIndex) +{ + CloseSocket(SocketIndex); +} +/***********************************************************************/ +char * __stdcall TCP_GetError(int SocketIndex) +{ + return (GetError(SocketIndex)); +} +/***********************************************************************/ +char * __stdcall GetLibraryVersion(void) +{ + return (DLL_VERSION); +} +/***********************************************************************/ +int __stdcall ElapsedTimeGet (int SocketIndex, double * ElapsedTime) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "ElapsedTimeGet (double *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", ElapsedTime); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall ErrorStringGet (int SocketIndex, int ErrorCode, char * ErrorString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "ErrorStringGet (%d,char *)", ErrorCode); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (ErrorString, pt); + ptNext = strchr (ErrorString, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall FirmwareVersionGet (int SocketIndex, char * Version) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "FirmwareVersionGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (Version, pt); + ptNext = strchr (Version, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall TCLScriptExecute (int SocketIndex, char * TCLFileName, char * TaskName, char * ParametersList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "TCLScriptExecute (%s,%s,%s)", TCLFileName, TaskName, ParametersList); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall TCLScriptKill (int SocketIndex, char * TaskName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "TCLScriptKill (%s)", TaskName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall TimerGet (int SocketIndex, char * TimerName, int * FrequencyTicks) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "TimerGet (%s,int *)", TimerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", FrequencyTicks); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall TimerSet (int SocketIndex, char * TimerName, int FrequencyTicks) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "TimerSet (%s,%d)", TimerName, FrequencyTicks); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall Reboot (int SocketIndex) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "Reboot ()"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall EventAdd (int SocketIndex, char * PositionerName, char * EventName, char * EventParameter, char * ActionName, char * ActionParameter1, char * ActionParameter2, char * ActionParameter3) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EventAdd (%s,%s,%s,%s,%s,%s,%s)", PositionerName, EventName, EventParameter, ActionName, ActionParameter1, ActionParameter2, ActionParameter3); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall EventGet (int SocketIndex, char * PositionerName, char * EventsAndActionsList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EventGet (%s,char *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (EventsAndActionsList, pt); + ptNext = strchr (EventsAndActionsList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall EventRemove (int SocketIndex, char * PositionerName, char * EventName, char * EventParameter) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EventRemove (%s,%s,%s)", PositionerName, EventName, EventParameter); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall EventWait (int SocketIndex, char * PositionerName, char * EventName, char * EventParameter) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EventWait (%s,%s,%s)", PositionerName, EventName, EventParameter); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringConfigurationGet (int SocketIndex, char * Type) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringConfigurationGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (Type, pt); + ptNext = strchr (Type, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringConfigurationSet (int SocketIndex, int NbElements, char * TypeList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Split list */ + char *token; + char seps[] = " \t;"; + int indice; + char list [SIZE_BUFFER]; + + char (*stringArray0)[SIZE_NAME]; + stringArray0 = new char [NbElements][SIZE_NAME]; + indice = 0; + strcpy (list, TypeList); + token = strtok( list, seps ); + while (( token != NULL ) && ( indice < NbElements )) + { + memset(stringArray0[indice],'\0', SIZE_NAME); + strcpy(stringArray0[indice], token); + token = strtok( NULL, seps ); + indice++; + } + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringConfigurationSet ("); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%s", stringArray0[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringCurrentNumberGet (int SocketIndex, int * CurrentNumber, int * MaximumSamplesNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringCurrentNumberGet (int *,int *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", CurrentNumber); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", MaximumSamplesNumber); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringStopAndSave (int SocketIndex) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringStopAndSave ()"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringExternalConfigurationSet (int SocketIndex, int NbElements, char * TypeList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Split list */ + char *token; + char seps[] = " \t;"; + int indice; + char list [SIZE_BUFFER]; + + char (*stringArray0)[SIZE_NAME]; + stringArray0 = new char [NbElements][SIZE_NAME]; + indice = 0; + strcpy (list, TypeList); + token = strtok( list, seps ); + while (( token != NULL ) && ( indice < NbElements )) + { + memset(stringArray0[indice],'\0', SIZE_NAME); + strcpy(stringArray0[indice], token); + token = strtok( NULL, seps ); + indice++; + } + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringExternalConfigurationSet ("); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%s", stringArray0[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringExternalConfigurationGet (int SocketIndex, char * Type) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringExternalConfigurationGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (Type, pt); + ptNext = strchr (Type, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringExternalCurrentNumberGet (int SocketIndex, int * CurrentNumber, int * MaximumSamplesNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringExternalCurrentNumberGet (int *,int *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", CurrentNumber); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", MaximumSamplesNumber); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringExternalStopAndSave (int SocketIndex) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringExternalStopAndSave ()"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GlobalArrayGet (int SocketIndex, int Number, char * ValueString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GlobalArrayGet (%d,char *)", Number); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (ValueString, pt); + ptNext = strchr (ValueString, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GlobalArraySet (int SocketIndex, int Number, char * ValueString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GlobalArraySet (%d,%s)", Number, ValueString); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GPIOAnalogGet (int SocketIndex, int NbElements, char * GPIONameList, double AnalogValue[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Split list */ + char *token; + char seps[] = " \t;"; + int indice; + char list [SIZE_BUFFER]; + + char (*stringArray0)[SIZE_NAME]; + stringArray0 = new char [NbElements][SIZE_NAME]; + indice = 0; + strcpy (list, GPIONameList); + token = strtok( list, seps ); + while (( token != NULL ) && ( indice < NbElements )) + { + memset(stringArray0[indice],'\0', SIZE_NAME); + strcpy(stringArray0[indice], token); + token = strtok( NULL, seps ); + indice++; + } + + /* Convert to string */ + sprintf (ExecuteMethod, "GPIOAnalogGet ("); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%s,double *", stringArray0[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &AnalogValue[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GPIOAnalogSet (int SocketIndex, int NbElements, char * GPIONameList, double AnalogOutputValue[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Split list */ + char *token; + char seps[] = " \t;"; + int indice; + char list [SIZE_BUFFER]; + + char (*stringArray0)[SIZE_NAME]; + stringArray0 = new char [NbElements][SIZE_NAME]; + indice = 0; + strcpy (list, GPIONameList); + token = strtok( list, seps ); + while (( token != NULL ) && ( indice < NbElements )) + { + memset(stringArray0[indice],'\0', SIZE_NAME); + strcpy(stringArray0[indice], token); + token = strtok( NULL, seps ); + indice++; + } + + /* Convert to string */ + sprintf (ExecuteMethod, "GPIOAnalogSet ("); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%s,%lf", stringArray0[i], AnalogOutputValue[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GPIOAnalogGainGet (int SocketIndex, int NbElements, char * GPIONameList, int AnalogInputGainValue[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Split list */ + char *token; + char seps[] = " \t;"; + int indice; + char list [SIZE_BUFFER]; + + char (*stringArray0)[SIZE_NAME]; + stringArray0 = new char [NbElements][SIZE_NAME]; + indice = 0; + strcpy (list, GPIONameList); + token = strtok( list, seps ); + while (( token != NULL ) && ( indice < NbElements )) + { + memset(stringArray0[indice],'\0', SIZE_NAME); + strcpy(stringArray0[indice], token); + token = strtok( NULL, seps ); + indice++; + } + + /* Convert to string */ + sprintf (ExecuteMethod, "GPIOAnalogGainGet ("); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%s,int *", stringArray0[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", &AnalogInputGainValue[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GPIOAnalogGainSet (int SocketIndex, int NbElements, char * GPIONameList, int AnalogInputGainValue[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Split list */ + char *token; + char seps[] = " \t;"; + int indice; + char list [SIZE_BUFFER]; + + char (*stringArray0)[SIZE_NAME]; + stringArray0 = new char [NbElements][SIZE_NAME]; + indice = 0; + strcpy (list, GPIONameList); + token = strtok( list, seps ); + while (( token != NULL ) && ( indice < NbElements )) + { + memset(stringArray0[indice],'\0', SIZE_NAME); + strcpy(stringArray0[indice], token); + token = strtok( NULL, seps ); + indice++; + } + + /* Convert to string */ + sprintf (ExecuteMethod, "GPIOAnalogGainSet ("); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%s,%d", stringArray0[i], AnalogInputGainValue[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GPIODigitalGet (int SocketIndex, char * GPIOName, unsigned short * DigitalValue) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GPIODigitalGet (%s,unsigned short *)", GPIOName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%u", DigitalValue); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GPIODigitalSet (int SocketIndex, char * GPIOName, unsigned short Mask, unsigned short DigitalOutputValue) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GPIODigitalSet (%s,%u,%u)", GPIOName, Mask, DigitalOutputValue); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupAnalogTrackingModeEnable (int SocketIndex, char * GroupName, char * Type) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupAnalogTrackingModeEnable (%s,%s)", GroupName, Type); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupAnalogTrackingModeDisable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupAnalogTrackingModeDisable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupHomeSearch (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupHomeSearch (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + + + /*SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); */ + SendOnly (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + + ret = 0; /* Added by JHK */ + + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupHomeSearchAndRelativeMove (int SocketIndex, char * GroupName, int NbElements, double TargetDisplacement[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupHomeSearchAndRelativeMove (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%lf", TargetDisplacement[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupInitialize (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupInitialize (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupJogParametersSet (int SocketIndex, char * GroupName, int NbElements, double Velocity[], double Acceleration[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupJogParametersSet (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%lf,%lf", Velocity[i], Acceleration[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupJogParametersGet (int SocketIndex, char * GroupName, int NbElements, double Velocity[], double Acceleration[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupJogParametersGet (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "double *,double *"); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &Velocity[i]); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &Acceleration[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupJogCurrentGet (int SocketIndex, char * GroupName, int NbElements, double Velocity[], double Acceleration[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupJogCurrentGet (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "double *,double *"); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &Velocity[i]); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &Acceleration[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupJogModeEnable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupJogModeEnable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupJogModeDisable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupJogModeDisable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupKill (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupKill (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupMoveAbort (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupMoveAbort (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupMoveAbsolute (int SocketIndex, char * GroupName, int NbElements, double TargetPosition[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupMoveAbsolute (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%lf", TargetPosition[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + + +/* printf("xps_c8_driver.cpp: GroupMoveAbs Calling SendAndRecieve\n");*/ + + /*SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue);*/ + SendOnly (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + + ret = 0; /* Added by JHK */ + + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupMoveRelative (int SocketIndex, char * GroupName, int NbElements, double TargetDisplacement[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupMoveRelative (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "%lf", TargetDisplacement[i]); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + printf("xps_c8_driver.cpp: GroupMoveRel Calling SendAndRecieve\n"); + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupMotionDisable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupMotionDisable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupMotionEnable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupMotionEnable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupPositionCurrentGet (int SocketIndex, char * GroupName, int NbElements, double CurrentEncoderPosition[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupPositionCurrentGet (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "double *"); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &CurrentEncoderPosition[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupPositionSetpointGet (int SocketIndex, char * GroupName, int NbElements, double SetPointPosition[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupPositionSetpointGet (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "double *"); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &SetPointPosition[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupPositionTargetGet (int SocketIndex, char * GroupName, int NbElements, double TargetPosition[]) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + char temp[SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupPositionTargetGet (%s,", GroupName); + for (int i = 0; i < NbElements; i++) + { + sprintf (temp, "double *"); + strcat (ExecuteMethod, temp); + if ((i + 1) < NbElements) + { + strcat (ExecuteMethod, ","); + } + } + strcat (ExecuteMethod, ")"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + + for (int i = 0; i < NbElements; i++) + { + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", &TargetPosition[i]); + } + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupStatusGet (int SocketIndex, char * GroupName, int * Status) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupStatusGet (%s,int *)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", Status); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupStatusStringGet (int SocketIndex, int GroupStatusCode, char * GroupStatusString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupStatusStringGet (%d,char *)", GroupStatusCode); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (GroupStatusString, pt); + ptNext = strchr (GroupStatusString, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall KillAll (int SocketIndex) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "KillAll ()"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerAnalogTrackingPositionParametersGet (int SocketIndex, char * PositionerName, char * GPIOName, double * Offset, double * Scale, double * Velocity, double * Acceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerAnalogTrackingPositionParametersGet (%s,char *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (GPIOName, pt); + ptNext = strchr (GPIOName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Offset); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Scale); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Velocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Acceleration); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerAnalogTrackingPositionParametersSet (int SocketIndex, char * PositionerName, char * GPIOName, double Offset, double Scale, double Velocity, double Acceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerAnalogTrackingPositionParametersSet (%s,%s,%lf,%lf,%lf,%lf)", PositionerName, GPIOName, Offset, Scale, Velocity, Acceleration); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerAnalogTrackingVelocityParametersGet (int SocketIndex, char * PositionerName, char * GPIOName, double * Offset, double * Scale, double * DeadBandThreshold, int * Order, double * Velocity, double * Acceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerAnalogTrackingVelocityParametersGet (%s,char *,double *,double *,double *,int *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (GPIOName, pt); + ptNext = strchr (GPIOName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Offset); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Scale); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", DeadBandThreshold); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", Order); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Velocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Acceleration); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerAnalogTrackingVelocityParametersSet (int SocketIndex, char * PositionerName, char * GPIOName, double Offset, double Scale, double DeadBandThreshold, int Order, double Velocity, double Acceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerAnalogTrackingVelocityParametersSet (%s,%s,%lf,%lf,%lf,%d,%lf,%lf)", PositionerName, GPIOName, Offset, Scale, DeadBandThreshold, Order, Velocity, Acceleration); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerBacklashGet (int SocketIndex, char * PositionerName, double * BacklashValue, char * BacklaskStatus) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerBacklashGet (%s,double *,char *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", BacklashValue); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (BacklaskStatus, pt); + ptNext = strchr (BacklaskStatus, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerBacklashSet (int SocketIndex, char * PositionerName, double BacklashValue) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerBacklashSet (%s,%lf)", PositionerName, BacklashValue); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerBacklashEnable (int SocketIndex, char * PositionerName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerBacklashEnable (%s)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerBacklashDisable (int SocketIndex, char * PositionerName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerBacklashDisable (%s)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorNotchFiltersSet (int SocketIndex, char * PositionerName, double NotchFrequency1, double NotchBandwith1, double NotchGain1, double NotchFrequency2, double NotchBandwith2, double NotchGain2) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorNotchFiltersSet (%s,%lf,%lf,%lf,%lf,%lf,%lf)", PositionerName, NotchFrequency1, NotchBandwith1, NotchGain1, NotchFrequency2, NotchBandwith2, NotchGain2); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorNotchFiltersGet (int SocketIndex, char * PositionerName, double * NotchFrequency1, double * NotchBandwith1, double * NotchGain1, double * NotchFrequency2, double * NotchBandwith2, double * NotchGain2) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorNotchFiltersGet (%s,double *,double *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", NotchFrequency1); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", NotchBandwith1); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", NotchGain1); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", NotchFrequency2); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", NotchBandwith2); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", NotchGain2); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIDFFAccelerationSet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double KD, double KS, double IntegrationTime, double DerivativeFilterCutOffFrequency, double GKP, double GKI, double GKD, double KForm, double FeedForwardGainAcceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIDFFAccelerationSet (%s,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf)", PositionerName, ClosedLoopStatus, KP, KI, KD, KS, IntegrationTime, DerivativeFilterCutOffFrequency, GKP, GKI, GKD, KForm, FeedForwardGainAcceleration); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIDFFAccelerationGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * KD, double * KS, double * IntegrationTime, double * DerivativeFilterCutOffFrequency, double * GKP, double * GKI, double * GKD, double * KForm, double * FeedForwardGainAcceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIDFFAccelerationGet (%s,bool *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", ClosedLoopStatus); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KD); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KS); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", IntegrationTime); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", DerivativeFilterCutOffFrequency); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKD); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KForm); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", FeedForwardGainAcceleration); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIDFFVelocitySet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double KD, double KS, double IntegrationTime, double DerivativeFilterCutOffFrequency, double GKP, double GKI, double GKD, double KForm, double FeedForwardGainVelocity) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIDFFVelocitySet (%s,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf)", PositionerName, ClosedLoopStatus, KP, KI, KD, KS, IntegrationTime, DerivativeFilterCutOffFrequency, GKP, GKI, GKD, KForm, FeedForwardGainVelocity); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIDFFVelocityGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * KD, double * KS, double * IntegrationTime, double * DerivativeFilterCutOffFrequency, double * GKP, double * GKI, double * GKD, double * KForm, double * FeedForwardGainVelocity) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIDFFVelocityGet (%s,bool *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", ClosedLoopStatus); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KD); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KS); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", IntegrationTime); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", DerivativeFilterCutOffFrequency); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKD); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KForm); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", FeedForwardGainVelocity); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIDDualFFVoltageSet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double KD, double KS, double IntegrationTime, double DerivativeFilterCutOffFrequency, double GKP, double GKI, double GKD, double KForm, double FeedForwardGainVelocity, double FeedForwardGainAcceleration, double Friction) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIDDualFFVoltageSet (%s,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf)", PositionerName, ClosedLoopStatus, KP, KI, KD, KS, IntegrationTime, DerivativeFilterCutOffFrequency, GKP, GKI, GKD, KForm, FeedForwardGainVelocity, FeedForwardGainAcceleration, Friction); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIDDualFFVoltageGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * KD, double * KS, double * IntegrationTime, double * DerivativeFilterCutOffFrequency, double * GKP, double * GKI, double * GKD, double * KForm, double * FeedForwardGainVelocity, double * FeedForwardGainAcceleration, double * Friction) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIDDualFFVoltageGet (%s,bool *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", ClosedLoopStatus); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KD); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KS); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", IntegrationTime); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", DerivativeFilterCutOffFrequency); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", GKD); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KForm); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", FeedForwardGainVelocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", FeedForwardGainAcceleration); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Friction); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIPositionSet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double IntegrationTime) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIPositionSet (%s,%d,%lf,%lf,%lf)", PositionerName, ClosedLoopStatus, KP, KI, IntegrationTime); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorPIPositionGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * IntegrationTime) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorPIPositionGet (%s,bool *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", ClosedLoopStatus); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KP); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", KI); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", IntegrationTime); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerCorrectorTypeGet (int SocketIndex, char * PositionerName, char * CorrectorType) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerCorrectorTypeGet (%s,char *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (CorrectorType, pt); + ptNext = strchr (CorrectorType, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerErrorGet (int SocketIndex, char * PositionerName, int * ErrorCode) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerErrorGet (%s,int *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", ErrorCode); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerErrorStringGet (int SocketIndex, int PositionerErrorCode, char * PositionerErrorString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerErrorStringGet (%d,char *)", PositionerErrorCode); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (PositionerErrorString, pt); + ptNext = strchr (PositionerErrorString, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerHardwareStatusGet (int SocketIndex, char * PositionerName, int * HardwareStatus) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerHardwareStatusGet (%s,int *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", HardwareStatus); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerHardwareStatusStringGet (int SocketIndex, int PositionerHardwareStatus, char * PositonerHardwareStatusString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerHardwareStatusStringGet (%d,char *)", PositionerHardwareStatus); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (PositonerHardwareStatusString, pt); + ptNext = strchr (PositonerHardwareStatusString, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerHardInterpolatorFactorGet (int SocketIndex, char * PositionerName, int * InterpolationFactor) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerHardInterpolatorFactorGet (%s,int *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", InterpolationFactor); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerHardInterpolatorFactorSet (int SocketIndex, char * PositionerName, int InterpolationFactor) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerHardInterpolatorFactorSet (%s,%d)", PositionerName, InterpolationFactor); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerMotionDoneGet (int SocketIndex, char * PositionerName, double * PositionWindow, double * VelocityWindow, double * CheckingTime, double * MeanPeriod, double * TimeOut) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerMotionDoneGet (%s,double *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", PositionWindow); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", VelocityWindow); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", CheckingTime); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MeanPeriod); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", TimeOut); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerMotionDoneSet (int SocketIndex, char * PositionerName, double PositionWindow, double VelocityWindow, double CheckingTime, double MeanPeriod, double TimeOut) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerMotionDoneSet (%s,%lf,%lf,%lf,%lf,%lf)", PositionerName, PositionWindow, VelocityWindow, CheckingTime, MeanPeriod, TimeOut); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerPositionCompareGet (int SocketIndex, char * PositionerName, double * MinimumPosition, double * MaximumPosition, double * PositionStep, bool * EnableState) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerPositionCompareGet (%s,double *,double *,double *,bool *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MinimumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", PositionStep); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", EnableState); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerPositionCompareSet (int SocketIndex, char * PositionerName, double MinimumPosition, double MaximumPosition, double PositionStep) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerPositionCompareSet (%s,%lf,%lf,%lf)", PositionerName, MinimumPosition, MaximumPosition, PositionStep); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerPositionCompareEnable (int SocketIndex, char * PositionerName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerPositionCompareEnable (%s)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerPositionCompareDisable (int SocketIndex, char * PositionerName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerPositionCompareDisable (%s)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerPreviousMotionTimesGet (int SocketIndex, char * PositionerName, double * SettingTime, double * SettlingTime) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerPreviousMotionTimesGet (%s,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", SettingTime); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", SettlingTime); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerSGammaParametersGet (int SocketIndex, char * PositionerName, double * Velocity, double * Acceleration, double * MinimumTjerkTime, double * MaximumTjerkTime) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerSGammaParametersGet (%s,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Velocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Acceleration); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MinimumTjerkTime); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumTjerkTime); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerSGammaParametersSet (int SocketIndex, char * PositionerName, double Velocity, double Acceleration, double MinimumTjerkTime, double MaximumTjerkTime) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerSGammaParametersSet (%s,%lf,%lf,%lf,%lf)", PositionerName, Velocity, Acceleration, MinimumTjerkTime, MaximumTjerkTime); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerSGammaExactVelocityAjustedDisplacementGet (int SocketIndex, char * PositionerName, double DesiredDisplacement, double * AdjustedDisplacement) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerSGammaExactVelocityAjustedDisplacementGet (%s,%lf,double *)", PositionerName, DesiredDisplacement); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", AdjustedDisplacement); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerUserTravelLimitsGet (int SocketIndex, char * PositionerName, double * UserMinimumTarget, double * UserMaximumTarget) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerUserTravelLimitsGet (%s,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserMinimumTarget); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserMaximumTarget); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerUserTravelLimitsSet (int SocketIndex, char * PositionerName, double UserMinimumTarget, double UserMaximumTarget) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerUserTravelLimitsSet (%s,%lf,%lf)", PositionerName, UserMinimumTarget, UserMaximumTarget); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall MultipleAxesPVTVerification (int SocketIndex, char * GroupName, char * FileName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "MultipleAxesPVTVerification (%s,%s)", GroupName, FileName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall MultipleAxesPVTVerificationResultGet (int SocketIndex, char * PositionerName, char * FileName, double * MinimumPosition, double * MaximumPosition, double * MaximumVelocity, double * MaximumAcceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "MultipleAxesPVTVerificationResultGet (%s,char *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (FileName, pt); + ptNext = strchr (FileName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MinimumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumVelocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumAcceleration); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall MultipleAxesPVTExecution (int SocketIndex, char * GroupName, char * FileName, int ExecutionNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "MultipleAxesPVTExecution (%s,%s,%d)", GroupName, FileName, ExecutionNumber); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall MultipleAxesPVTParametersGet (int SocketIndex, char * GroupName, char * FileName, int * CurrentElementNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "MultipleAxesPVTParametersGet (%s,char *,int *)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (FileName, pt); + ptNext = strchr (FileName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", CurrentElementNumber); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall SingleAxisSlaveModeEnable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "SingleAxisSlaveModeEnable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall SingleAxisSlaveModeDisable (int SocketIndex, char * GroupName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "SingleAxisSlaveModeDisable (%s)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall SingleAxisSlaveParametersSet (int SocketIndex, char * GroupName, char * PositionerName, double Ratio) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "SingleAxisSlaveParametersSet (%s,%s,%lf)", GroupName, PositionerName, Ratio); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall SingleAxisSlaveParametersGet (int SocketIndex, char * GroupName, char * PositionerName, double * Ratio) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "SingleAxisSlaveParametersGet (%s,char *,double *)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (PositionerName, pt); + ptNext = strchr (PositionerName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Ratio); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYLineArcVerification (int SocketIndex, char * GroupName, char * FileName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYLineArcVerification (%s,%s)", GroupName, FileName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYLineArcVerificationResultGet (int SocketIndex, char * PositionerName, char * FileName, double * MinimumPosition, double * MaximumPosition, double * MaximumVelocity, double * MaximumAcceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYLineArcVerificationResultGet (%s,char *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (FileName, pt); + ptNext = strchr (FileName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MinimumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumVelocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumAcceleration); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYLineArcExecution (int SocketIndex, char * GroupName, char * FileName, double Velocity, double Acceleration, int ExecutionNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYLineArcExecution (%s,%s,%lf,%lf,%d)", GroupName, FileName, Velocity, Acceleration, ExecutionNumber); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYLineArcParametersGet (int SocketIndex, char * GroupName, char * FileName, double * Velocity, double * Acceleration, int * CurrentElementNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYLineArcParametersGet (%s,char *,double *,double *,int *)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (FileName, pt); + ptNext = strchr (FileName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Velocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Acceleration); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", CurrentElementNumber); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYZSplineVerification (int SocketIndex, char * GroupName, char * FileName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYZSplineVerification (%s,%s)", GroupName, FileName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYZSplineVerificationResultGet (int SocketIndex, char * PositionerName, char * FileName, double * MinimumPosition, double * MaximumPosition, double * MaximumVelocity, double * MaximumAcceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYZSplineVerificationResultGet (%s,char *,double *,double *,double *,double *)", PositionerName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (FileName, pt); + ptNext = strchr (FileName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MinimumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumPosition); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumVelocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", MaximumAcceleration); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYZSplineExecution (int SocketIndex, char * GroupName, char * FileName, double Velocity, double Acceleration) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYZSplineExecution (%s,%s,%lf,%lf)", GroupName, FileName, Velocity, Acceleration); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall XYZSplineParametersGet (int SocketIndex, char * GroupName, char * FileName, double * Velocity, double * Acceleration, int * CurrentElementNumber) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "XYZSplineParametersGet (%s,char *,double *,double *,int *)", GroupName); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (FileName, pt); + ptNext = strchr (FileName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Velocity); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", Acceleration); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%d", CurrentElementNumber); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall EEPROMCIESet (int SocketIndex, int CardNumber, char * ReferenceString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EEPROMCIESet (%d,%s)", CardNumber, ReferenceString); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall EEPROMDACOffsetCIESet (int SocketIndex, int PlugNumber, double DAC1Offset, double DAC2Offset) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EEPROMDACOffsetCIESet (%d,%lf,%lf)", PlugNumber, DAC1Offset, DAC2Offset); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall EEPROMDriverSet (int SocketIndex, int PlugNumber, char * ReferenceString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EEPROMDriverSet (%d,%s)", PlugNumber, ReferenceString); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall EEPROMINTSet (int SocketIndex, int CardNumber, char * ReferenceString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EEPROMINTSet (%d,%s)", CardNumber, ReferenceString); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + return (ret); +} + + +/***********************************************************************/ +int __stdcall ActionListGet (int SocketIndex, char * ActionList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "ActionListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (ActionList, pt); + ptNext = strchr (ActionList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall APIExtendedListGet (int SocketIndex, char * Method) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "APIExtendedListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (Method, pt); + ptNext = strchr (Method, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall APIListGet (int SocketIndex, char * Method) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "APIListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (Method, pt); + ptNext = strchr (Method, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall ErrorListGet (int SocketIndex, char * ErrorsList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "ErrorListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (ErrorsList, pt); + ptNext = strchr (ErrorsList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall EventListGet (int SocketIndex, char * EventList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "EventListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (EventList, pt); + ptNext = strchr (EventList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringListGet (int SocketIndex, char * list) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (list, pt); + ptNext = strchr (list, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringExtendedListGet (int SocketIndex, char * list) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringExtendedListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (list, pt); + ptNext = strchr (list, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringExternalListGet (int SocketIndex, char * list) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringExternalListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (list, pt); + ptNext = strchr (list, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GroupStatusListGet (int SocketIndex, char * GroupStatusList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GroupStatusListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (GroupStatusList, pt); + ptNext = strchr (GroupStatusList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall HardwareInternalListGet (int SocketIndex, char * InternalHardwareList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "HardwareInternalListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (InternalHardwareList, pt); + ptNext = strchr (InternalHardwareList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall HardwareDriverAndStageGet (int SocketIndex, int PlugNumber, char * DriverName, char * StageName) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "HardwareDriverAndStageGet (%d,char *,char *)", PlugNumber); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (DriverName, pt); + ptNext = strchr (DriverName, ','); + if (ptNext != NULL) *ptNext = '\0'; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (StageName, pt); + ptNext = strchr (StageName, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall ObjectsListGet (int SocketIndex, char * ObjectsList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "ObjectsListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (ObjectsList, pt); + ptNext = strchr (ObjectsList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerErrorListGet (int SocketIndex, char * PositionerErrorList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerErrorListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (PositionerErrorList, pt); + ptNext = strchr (PositionerErrorList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall PositionerHardwareStatusListGet (int SocketIndex, char * PositionerHardwareStatusList) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "PositionerHardwareStatusListGet (char *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (PositionerHardwareStatusList, pt); + ptNext = strchr (PositionerHardwareStatusList, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall GatheringUserDatasGet (int SocketIndex, double * UserData1, double * UserData2, double * UserData3, double * UserData4, double * UserData5, double * UserData6, double * UserData7, double * UserData8) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "GatheringUserDatasGet (double *,double *,double *,double *,double *,double *,double *,double *)"); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData1); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData2); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData3); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData4); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData5); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData6); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData7); + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) sscanf (pt, "%lf", UserData8); + } + return (ret); +} + + +/***********************************************************************/ +int __stdcall TestTCP (int SocketIndex, char * InputString, char * ReturnString) +{ + int ret = -1; + char ExecuteMethod [SIZE_BUFFER]; + char ReturnedValue [SIZE_BUFFER]; + + /* Convert to string */ + sprintf (ExecuteMethod, "TestTCP (%s,char *)", InputString); + + /* Send this string and wait return function from controller */ + /* return function : ==0 -> OK ; < 0 -> NOK */ + SendAndReceive (SocketIndex, ExecuteMethod, ReturnedValue); + if (strlen (ReturnedValue) > 0) + sscanf (ReturnedValue, "%i", &ret); + + /* Get the returned values in the out parameters */ + if (ret == 0) + { + char * pt; + char * ptNext; + + pt = ReturnedValue; + ptNext = NULL; + if (pt != NULL) pt = strchr (pt, ','); + if (pt != NULL) pt++; + if (pt != NULL) strcpy (ReturnString, pt); + ptNext = strchr (ReturnString, ','); + if (ptNext != NULL) *ptNext = '\0'; + } + return (ret); +} + + + + +#ifdef __cplusplus +} +#endif diff --git a/motorApp/NewportSrc/xps_c8_driver.h b/motorApp/NewportSrc/xps_c8_driver.h new file mode 100755 index 00000000..23ed1788 --- /dev/null +++ b/motorApp/NewportSrc/xps_c8_driver.h @@ -0,0 +1,157 @@ +//////////////////////////////////////////////////////////////////// +// Created header file api.h for API headings +// + + +/*#ifndef DLL +#define DLL _declspec(dllimport) +#endif*/ +#ifdef WINDOWS /* Copied from old version*/ +#ifndef DLL +#define DLL _declspec(dllimport) +#endif +#else +#define __stdcall +#define DLL +#endif + + +#ifdef __cplusplus +extern "C" +{ +#endif + + +DLL int __stdcall TCP_ConnectToServer(char *Ip_Address, int Ip_Port, double TimeOut); +DLL void __stdcall TCP_SetTimeout(int SocketIndex, double Timeout); +DLL void __stdcall TCP_CloseSocket(int SocketIndex); +DLL char * __stdcall TCP_GetError(int SocketIndex); +DLL char * __stdcall GetLibraryVersion(void); +DLL int __stdcall ElapsedTimeGet (int SocketIndex, double * ElapsedTime); +DLL int __stdcall ErrorStringGet (int SocketIndex, int ErrorCode, char * ErrorString); +DLL int __stdcall FirmwareVersionGet (int SocketIndex, char * Version); +DLL int __stdcall TCLScriptExecute (int SocketIndex, char * TCLFileName, char * TaskName, char * ParametersList); +DLL int __stdcall TCLScriptKill (int SocketIndex, char * TaskName); +DLL int __stdcall TimerGet (int SocketIndex, char * TimerName, int * FrequencyTicks); +DLL int __stdcall TimerSet (int SocketIndex, char * TimerName, int FrequencyTicks); +DLL int __stdcall Reboot (int SocketIndex); +DLL int __stdcall EventAdd (int SocketIndex, char * PositionerName, char * EventName, char * EventParameter, char * ActionName, char * ActionParameter1, char * ActionParameter2, char * ActionParameter3); +DLL int __stdcall EventGet (int SocketIndex, char * PositionerName, char * EventsAndActionsList); +DLL int __stdcall EventRemove (int SocketIndex, char * PositionerName, char * EventName, char * EventParameter); +DLL int __stdcall EventWait (int SocketIndex, char * PositionerName, char * EventName, char * EventParameter); +DLL int __stdcall GatheringConfigurationGet (int SocketIndex, char * Type); +DLL int __stdcall GatheringConfigurationSet (int SocketIndex, int NbElements, char * TypeList); +DLL int __stdcall GatheringCurrentNumberGet (int SocketIndex, int * CurrentNumber, int * MaximumSamplesNumber); +DLL int __stdcall GatheringStopAndSave (int SocketIndex); +DLL int __stdcall GatheringExternalConfigurationSet (int SocketIndex, int NbElements, char * TypeList); +DLL int __stdcall GatheringExternalConfigurationGet (int SocketIndex, char * Type); +DLL int __stdcall GatheringExternalCurrentNumberGet (int SocketIndex, int * CurrentNumber, int * MaximumSamplesNumber); +DLL int __stdcall GatheringExternalStopAndSave (int SocketIndex); +DLL int __stdcall GlobalArrayGet (int SocketIndex, int Number, char * ValueString); +DLL int __stdcall GlobalArraySet (int SocketIndex, int Number, char * ValueString); +DLL int __stdcall GPIOAnalogGet (int SocketIndex, int NbElements, char * GPIONameList, double AnalogValue[]); +DLL int __stdcall GPIOAnalogSet (int SocketIndex, int NbElements, char * GPIONameList, double AnalogOutputValue[]); +DLL int __stdcall GPIOAnalogGainGet (int SocketIndex, int NbElements, char * GPIONameList, int AnalogInputGainValue[]); +DLL int __stdcall GPIOAnalogGainSet (int SocketIndex, int NbElements, char * GPIONameList, int AnalogInputGainValue[]); +DLL int __stdcall GPIODigitalGet (int SocketIndex, char * GPIOName, unsigned short * DigitalValue); +DLL int __stdcall GPIODigitalSet (int SocketIndex, char * GPIOName, unsigned short Mask, unsigned short DigitalOutputValue); +DLL int __stdcall GroupAnalogTrackingModeEnable (int SocketIndex, char * GroupName, char * Type); +DLL int __stdcall GroupAnalogTrackingModeDisable (int SocketIndex, char * GroupName); +DLL int __stdcall GroupHomeSearch (int SocketIndex, char * GroupName); +DLL int __stdcall GroupHomeSearchAndRelativeMove (int SocketIndex, char * GroupName, int NbElements, double TargetDisplacement[]); +DLL int __stdcall GroupInitialize (int SocketIndex, char * GroupName); +DLL int __stdcall GroupJogParametersSet (int SocketIndex, char * GroupName, int NbElements, double Velocity[], double Acceleration[]); +DLL int __stdcall GroupJogParametersGet (int SocketIndex, char * GroupName, int NbElements, double Velocity[], double Acceleration[]); +DLL int __stdcall GroupJogCurrentGet (int SocketIndex, char * GroupName, int NbElements, double Velocity[], double Acceleration[]); +DLL int __stdcall GroupJogModeEnable (int SocketIndex, char * GroupName); +DLL int __stdcall GroupJogModeDisable (int SocketIndex, char * GroupName); +DLL int __stdcall GroupKill (int SocketIndex, char * GroupName); +DLL int __stdcall GroupMoveAbort (int SocketIndex, char * GroupName); +DLL int __stdcall GroupMoveAbsolute (int SocketIndex, char * GroupName, int NbElements, double TargetPosition[]); +DLL int __stdcall GroupMoveRelative (int SocketIndex, char * GroupName, int NbElements, double TargetDisplacement[]); +DLL int __stdcall GroupMotionDisable (int SocketIndex, char * GroupName); +DLL int __stdcall GroupMotionEnable (int SocketIndex, char * GroupName); +DLL int __stdcall GroupPositionCurrentGet (int SocketIndex, char * GroupName, int NbElements, double CurrentEncoderPosition[]); +DLL int __stdcall GroupPositionSetpointGet (int SocketIndex, char * GroupName, int NbElements, double SetPointPosition[]); +DLL int __stdcall GroupPositionTargetGet (int SocketIndex, char * GroupName, int NbElements, double TargetPosition[]); +DLL int __stdcall GroupStatusGet (int SocketIndex, char * GroupName, int * Status); +DLL int __stdcall GroupStatusStringGet (int SocketIndex, int GroupStatusCode, char * GroupStatusString); +DLL int __stdcall KillAll (int SocketIndex); +DLL int __stdcall PositionerAnalogTrackingPositionParametersGet (int SocketIndex, char * PositionerName, char * GPIOName, double * Offset, double * Scale, double * Velocity, double * Acceleration); +DLL int __stdcall PositionerAnalogTrackingPositionParametersSet (int SocketIndex, char * PositionerName, char * GPIOName, double Offset, double Scale, double Velocity, double Acceleration); +DLL int __stdcall PositionerAnalogTrackingVelocityParametersGet (int SocketIndex, char * PositionerName, char * GPIOName, double * Offset, double * Scale, double * DeadBandThreshold, int * Order, double * Velocity, double * Acceleration); +DLL int __stdcall PositionerAnalogTrackingVelocityParametersSet (int SocketIndex, char * PositionerName, char * GPIOName, double Offset, double Scale, double DeadBandThreshold, int Order, double Velocity, double Acceleration); +DLL int __stdcall PositionerBacklashGet (int SocketIndex, char * PositionerName, double * BacklashValue, char * BacklaskStatus); +DLL int __stdcall PositionerBacklashSet (int SocketIndex, char * PositionerName, double BacklashValue); +DLL int __stdcall PositionerBacklashEnable (int SocketIndex, char * PositionerName); +DLL int __stdcall PositionerBacklashDisable (int SocketIndex, char * PositionerName); +DLL int __stdcall PositionerCorrectorNotchFiltersSet (int SocketIndex, char * PositionerName, double NotchFrequency1, double NotchBandwith1, double NotchGain1, double NotchFrequency2, double NotchBandwith2, double NotchGain2); +DLL int __stdcall PositionerCorrectorNotchFiltersGet (int SocketIndex, char * PositionerName, double * NotchFrequency1, double * NotchBandwith1, double * NotchGain1, double * NotchFrequency2, double * NotchBandwith2, double * NotchGain2); +DLL int __stdcall PositionerCorrectorPIDFFAccelerationSet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double KD, double KS, double IntegrationTime, double DerivativeFilterCutOffFrequency, double GKP, double GKI, double GKD, double KForm, double FeedForwardGainAcceleration); +DLL int __stdcall PositionerCorrectorPIDFFAccelerationGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * KD, double * KS, double * IntegrationTime, double * DerivativeFilterCutOffFrequency, double * GKP, double * GKI, double * GKD, double * KForm, double * FeedForwardGainAcceleration); +DLL int __stdcall PositionerCorrectorPIDFFVelocitySet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double KD, double KS, double IntegrationTime, double DerivativeFilterCutOffFrequency, double GKP, double GKI, double GKD, double KForm, double FeedForwardGainVelocity); +DLL int __stdcall PositionerCorrectorPIDFFVelocityGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * KD, double * KS, double * IntegrationTime, double * DerivativeFilterCutOffFrequency, double * GKP, double * GKI, double * GKD, double * KForm, double * FeedForwardGainVelocity); +DLL int __stdcall PositionerCorrectorPIDDualFFVoltageSet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double KD, double KS, double IntegrationTime, double DerivativeFilterCutOffFrequency, double GKP, double GKI, double GKD, double KForm, double FeedForwardGainVelocity, double FeedForwardGainAcceleration, double Friction); +DLL int __stdcall PositionerCorrectorPIDDualFFVoltageGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * KD, double * KS, double * IntegrationTime, double * DerivativeFilterCutOffFrequency, double * GKP, double * GKI, double * GKD, double * KForm, double * FeedForwardGainVelocity, double * FeedForwardGainAcceleration, double * Friction); +DLL int __stdcall PositionerCorrectorPIPositionSet (int SocketIndex, char * PositionerName, bool ClosedLoopStatus, double KP, double KI, double IntegrationTime); +DLL int __stdcall PositionerCorrectorPIPositionGet (int SocketIndex, char * PositionerName, bool * ClosedLoopStatus, double * KP, double * KI, double * IntegrationTime); +DLL int __stdcall PositionerCorrectorTypeGet (int SocketIndex, char * PositionerName, char * CorrectorType); +DLL int __stdcall PositionerErrorGet (int SocketIndex, char * PositionerName, int * ErrorCode); +DLL int __stdcall PositionerErrorStringGet (int SocketIndex, int PositionerErrorCode, char * PositionerErrorString); +DLL int __stdcall PositionerHardwareStatusGet (int SocketIndex, char * PositionerName, int * HardwareStatus); +DLL int __stdcall PositionerHardwareStatusStringGet (int SocketIndex, int PositionerHardwareStatus, char * PositonerHardwareStatusString); +DLL int __stdcall PositionerHardInterpolatorFactorGet (int SocketIndex, char * PositionerName, int * InterpolationFactor); +DLL int __stdcall PositionerHardInterpolatorFactorSet (int SocketIndex, char * PositionerName, int InterpolationFactor); +DLL int __stdcall PositionerMotionDoneGet (int SocketIndex, char * PositionerName, double * PositionWindow, double * VelocityWindow, double * CheckingTime, double * MeanPeriod, double * TimeOut); +DLL int __stdcall PositionerMotionDoneSet (int SocketIndex, char * PositionerName, double PositionWindow, double VelocityWindow, double CheckingTime, double MeanPeriod, double TimeOut); +DLL int __stdcall PositionerPositionCompareGet (int SocketIndex, char * PositionerName, double * MinimumPosition, double * MaximumPosition, double * PositionStep, bool * EnableState); +DLL int __stdcall PositionerPositionCompareSet (int SocketIndex, char * PositionerName, double MinimumPosition, double MaximumPosition, double PositionStep); +DLL int __stdcall PositionerPositionCompareEnable (int SocketIndex, char * PositionerName); +DLL int __stdcall PositionerPositionCompareDisable (int SocketIndex, char * PositionerName); +DLL int __stdcall PositionerPreviousMotionTimesGet (int SocketIndex, char * PositionerName, double * SettingTime, double * SettlingTime); +DLL int __stdcall PositionerSGammaParametersGet (int SocketIndex, char * PositionerName, double * Velocity, double * Acceleration, double * MinimumTjerkTime, double * MaximumTjerkTime); +DLL int __stdcall PositionerSGammaParametersSet (int SocketIndex, char * PositionerName, double Velocity, double Acceleration, double MinimumTjerkTime, double MaximumTjerkTime); +DLL int __stdcall PositionerSGammaExactVelocityAjustedDisplacementGet (int SocketIndex, char * PositionerName, double DesiredDisplacement, double * AdjustedDisplacement); +DLL int __stdcall PositionerUserTravelLimitsGet (int SocketIndex, char * PositionerName, double * UserMinimumTarget, double * UserMaximumTarget); +DLL int __stdcall PositionerUserTravelLimitsSet (int SocketIndex, char * PositionerName, double UserMinimumTarget, double UserMaximumTarget); +DLL int __stdcall MultipleAxesPVTVerification (int SocketIndex, char * GroupName, char * FileName); +DLL int __stdcall MultipleAxesPVTVerificationResultGet (int SocketIndex, char * PositionerName, char * FileName, double * MinimumPosition, double * MaximumPosition, double * MaximumVelocity, double * MaximumAcceleration); +DLL int __stdcall MultipleAxesPVTExecution (int SocketIndex, char * GroupName, char * FileName, int ExecutionNumber); +DLL int __stdcall MultipleAxesPVTParametersGet (int SocketIndex, char * GroupName, char * FileName, int * CurrentElementNumber); +DLL int __stdcall SingleAxisSlaveModeEnable (int SocketIndex, char * GroupName); +DLL int __stdcall SingleAxisSlaveModeDisable (int SocketIndex, char * GroupName); +DLL int __stdcall SingleAxisSlaveParametersSet (int SocketIndex, char * GroupName, char * PositionerName, double Ratio); +DLL int __stdcall SingleAxisSlaveParametersGet (int SocketIndex, char * GroupName, char * PositionerName, double * Ratio); +DLL int __stdcall XYLineArcVerification (int SocketIndex, char * GroupName, char * FileName); +DLL int __stdcall XYLineArcVerificationResultGet (int SocketIndex, char * PositionerName, char * FileName, double * MinimumPosition, double * MaximumPosition, double * MaximumVelocity, double * MaximumAcceleration); +DLL int __stdcall XYLineArcExecution (int SocketIndex, char * GroupName, char * FileName, double Velocity, double Acceleration, int ExecutionNumber); +DLL int __stdcall XYLineArcParametersGet (int SocketIndex, char * GroupName, char * FileName, double * Velocity, double * Acceleration, int * CurrentElementNumber); +DLL int __stdcall XYZSplineVerification (int SocketIndex, char * GroupName, char * FileName); +DLL int __stdcall XYZSplineVerificationResultGet (int SocketIndex, char * PositionerName, char * FileName, double * MinimumPosition, double * MaximumPosition, double * MaximumVelocity, double * MaximumAcceleration); +DLL int __stdcall XYZSplineExecution (int SocketIndex, char * GroupName, char * FileName, double Velocity, double Acceleration); +DLL int __stdcall XYZSplineParametersGet (int SocketIndex, char * GroupName, char * FileName, double * Velocity, double * Acceleration, int * CurrentElementNumber); +DLL int __stdcall EEPROMCIESet (int SocketIndex, int CardNumber, char * ReferenceString); +DLL int __stdcall EEPROMDACOffsetCIESet (int SocketIndex, int PlugNumber, double DAC1Offset, double DAC2Offset); +DLL int __stdcall EEPROMDriverSet (int SocketIndex, int PlugNumber, char * ReferenceString); +DLL int __stdcall EEPROMINTSet (int SocketIndex, int CardNumber, char * ReferenceString); +DLL int __stdcall ActionListGet (int SocketIndex, char * ActionList); +DLL int __stdcall APIExtendedListGet (int SocketIndex, char * Method); +DLL int __stdcall APIListGet (int SocketIndex, char * Method); +DLL int __stdcall ErrorListGet (int SocketIndex, char * ErrorsList); +DLL int __stdcall EventListGet (int SocketIndex, char * EventList); +DLL int __stdcall GatheringListGet (int SocketIndex, char * list); +DLL int __stdcall GatheringExtendedListGet (int SocketIndex, char * list); +DLL int __stdcall GatheringExternalListGet (int SocketIndex, char * list); +DLL int __stdcall GroupStatusListGet (int SocketIndex, char * GroupStatusList); +DLL int __stdcall HardwareInternalListGet (int SocketIndex, char * InternalHardwareList); +DLL int __stdcall HardwareDriverAndStageGet (int SocketIndex, int PlugNumber, char * DriverName, char * StageName); +DLL int __stdcall ObjectsListGet (int SocketIndex, char * ObjectsList); +DLL int __stdcall PositionerErrorListGet (int SocketIndex, char * PositionerErrorList); +DLL int __stdcall PositionerHardwareStatusListGet (int SocketIndex, char * PositionerHardwareStatusList); +DLL int __stdcall GatheringUserDatasGet (int SocketIndex, double * UserData1, double * UserData2, double * UserData3, double * UserData4, double * UserData5, double * UserData6, double * UserData7, double * UserData8); +DLL int __stdcall TestTCP (int SocketIndex, char * InputString, char * ReturnString); + + +#ifdef __cplusplus +} +#endif