From 60bb0f3c16376d31a3699303469db035f8676e08 Mon Sep 17 00:00:00 2001 From: jsullivan-anl Date: Thu, 14 Jun 2007 15:56:59 +0000 Subject: [PATCH] Intial development release --- motorApp/PiJenaSrc/Makefile | 20 + motorApp/PiJenaSrc/PIJEDS_Register.cc | 68 +++ motorApp/PiJenaSrc/README | 109 ++++ motorApp/PiJenaSrc/devPIJEDS.cc | 317 ++++++++++++ motorApp/PiJenaSrc/devPIJena.dbd | 7 + motorApp/PiJenaSrc/drvPIJEDS.cc | 711 ++++++++++++++++++++++++++ motorApp/PiJenaSrc/drvPIJEDS.h | 85 +++ 7 files changed, 1317 insertions(+) create mode 100644 motorApp/PiJenaSrc/Makefile create mode 100644 motorApp/PiJenaSrc/PIJEDS_Register.cc create mode 100644 motorApp/PiJenaSrc/README create mode 100644 motorApp/PiJenaSrc/devPIJEDS.cc create mode 100644 motorApp/PiJenaSrc/devPIJena.dbd create mode 100644 motorApp/PiJenaSrc/drvPIJEDS.cc create mode 100644 motorApp/PiJenaSrc/drvPIJEDS.h diff --git a/motorApp/PiJenaSrc/Makefile b/motorApp/PiJenaSrc/Makefile new file mode 100644 index 00000000..37d05265 --- /dev/null +++ b/motorApp/PiJenaSrc/Makefile @@ -0,0 +1,20 @@ +# Makefile +TOP = ../.. +include $(TOP)/configure/CONFIG + +# Both the following line, and a line in the *.dbd file, +# must be uncommented to use diagnostic debugging messages. +USR_CXXFLAGS += -DDEBUG + +DBD += devPIJena.dbd + +LIBRARY_IOC = PIJena + +# piezosystem jena motor controller support +SRCS += devPIJEDS.cc drvPIJEDS.cc PIJEDS_Register.cc + +PIJena_LIBS += motor asyn +PIJena_LIBS += $(EPICS_BASE_IOC_LIBS) + +include $(TOP)/configure/RULES + diff --git a/motorApp/PiJenaSrc/PIJEDS_Register.cc b/motorApp/PiJenaSrc/PIJEDS_Register.cc new file mode 100644 index 00000000..c9a41205 --- /dev/null +++ b/motorApp/PiJenaSrc/PIJEDS_Register.cc @@ -0,0 +1,68 @@ +/* +FILENAME... PIJEDS_Register.cc +USAGE... Register piezosystem jena motor device driver shell commands. + +Version: $Revision: 1.1 $ +Modified By: $Author: sullivan $ +Last Modified: $Date: 2007-06-14 15:56:59 $ +*/ + +/***************************************************************** + COPYRIGHT NOTIFICATION +***************************************************************** + +(C) COPYRIGHT 1993 UNIVERSITY OF CHICAGO + +This software was developed under a United States Government license +described on the COPYRIGHT_UniversityOfChicago file included as part +of this distribution. +**********************************************************************/ + +#include +#include +#include +#include +#include +#include "motor.h" +#include "drvPIJEDS.h" +#include "epicsExport.h" + +extern "C" +{ + +// Pi Setup arguments +static const iocshArg setupArg0 = {"Max. controller count", iocshArgInt}; +static const iocshArg setupArg1 = {"Polling rate", iocshArgInt}; +// Pi Config arguments +static const iocshArg configArg0 = {"Card being configured", iocshArgInt}; +static const iocshArg configArg1 = {"asyn port name", iocshArgString}; +static const iocshArg configArg2 = {"asyn address (GPIB)", iocshArgInt}; + +static const iocshArg * const PIJEDSSetupArgs[2] = {&setupArg0, &setupArg1}; +static const iocshArg * const PIJEDSConfigArgs[3] = {&configArg0, &configArg1, + &configArg2}; + +static const iocshFuncDef setupPIJEDS = {"PIJEDSSetup", 2, PIJEDSSetupArgs}; +static const iocshFuncDef configPIJEDS = {"PIJEDSConfig", 3, PIJEDSConfigArgs}; + +static void setupPIJEDSCallFunc(const iocshArgBuf *args) +{ + PIJEDSSetup(args[0].ival, args[1].ival); +} + + +static void configPIJEDSCallFunc(const iocshArgBuf *args) +{ + PIJEDSConfig(args[0].ival, args[1].sval, args[2].ival); +} + + +static void PIJEDSmotorRegister(void) +{ + iocshRegister(&setupPIJEDS, setupPIJEDSCallFunc); + iocshRegister(&configPIJEDS, configPIJEDSCallFunc); +} + +epicsExportRegistrar(PIJEDSmotorRegister); + +} // extern "C" diff --git a/motorApp/PiJenaSrc/README b/motorApp/PiJenaSrc/README new file mode 100644 index 00000000..6388e98e --- /dev/null +++ b/motorApp/PiJenaSrc/README @@ -0,0 +1,109 @@ +Digital Piezo Controller +piezosystem jena +www.piezojena.com + +Model: EDS + +Tested Version: EDS2, DSM V1.959 + + +RS232: + 9600,8,1,N (See setup warning below) + RX EOL: '/r' (13) + TX FRAMING: '/023'/r/n'/021' + +Commands: + ,,[] + Where axis = 0, 1, ...,5 + + * Reply from motion commands '/023/021' (framing characters only) + * Single command per line + +Query Reply: ,, + *** WARNING *** Printing the EDS responses (during debugging) + lockup the vxWorks terminal session (using cu) because + of the framing characters. + +Position Resolution: 0.001 micrometers (um) + +DRIVER SUPPORT EXCEPTIONS: + NO Relative Motion + NO JOG command + NO DONE indicator + NO Homing + NO Limit Switches + +SET_STATUS NOTES: + DONE: No DONE indicator so the 'no motion' test is used + to set the DONE status. + + No Motion Test: Reference position is not available so + the 'no motion' test was widen to a hard coded + tolerance value based on the MAXIMUM RESOLUTION. + This was needed because of encoder jitter. + + +=================== CONTROLLER SETUP ================= + BAUD RATE: 115200 BAUD must be lowered to 9600 to work + with the IP-OCTAL card (VxWorks IOC's). + + ***WARNING*** + The 9600 baud setting does NOT work after the EDS2 is power cycled. + Re-entering the 9600 baud setting is required. + + Use Controller's Screen to access motion parameters (PID, notch filter) + + PID parameters are not implemented in EPICS device driver because + the other motion calibration settings are not available from EPICS. + + +=================== MOTION ================= +ENABLE/DISABLE Servo - ClosedLoop/OpenLoop + cl,,[1/0] + +MOVE Absolute (set displacement) + set,,<0 to xxx.xxx> + +MOVE Relative + + +GO HOME + + +SET VELOCITY (slew rate) + sr,, + + Units: 0.001 ... 500.0 V/ms + +STOP MOTION + + +=================== STATUS ================= + +READ Version Info + \r + Return: + + + +READ Commanded position + + +READ Feedback position + mess, + Response: 0 to xxx.xxx um + +READ Velocity (programmed) + sr, + Units: 0.001 ... 500.0 V/ms + +ON-TARGET: + + +SERVO ENABLE + stat, + 16bit register - bit 7 + + + + diff --git a/motorApp/PiJenaSrc/devPIJEDS.cc b/motorApp/PiJenaSrc/devPIJEDS.cc new file mode 100644 index 00000000..e6d5ba69 --- /dev/null +++ b/motorApp/PiJenaSrc/devPIJEDS.cc @@ -0,0 +1,317 @@ +/* +FILENAME... devPIJEDS.cc +USAGE... Motor record device level support for Physik Instrumente (PI) + GmbH & Co. E-516 motor controller. + +Version: $Revision: 1.1 $ +Modified By: $Author: sullivan $ +Last Modified: $Date: 2007-06-14 15:56:59 $ +*/ + +/* + * Original Author: Joe Sullivan + * Date: 6/07 + * + * Experimental Physics and Industrial Control System (EPICS) + * + * Copyright 1991, the Regents of the University of California, + * and the University of Chicago Board of Governors. + * + * This software was produced under U.S. Government contracts: + * (W-7405-ENG-36) at the Los Alamos National Laboratory, + * and (W-31-109-ENG-38) at Argonne National Laboratory. + * + * Initial development by: + * The Controls and Automation Group (AT-8) + * Ground Test Accelerator + * Accelerator Technology Division + * Los Alamos National Laboratory + * + * Co-developed with + * The Controls and Computing Group + * Accelerator Systems Division + * Advanced Photon Source + * Argonne National Laboratory + * + * Modification Log: + * ----------------- + * .01 01/29/06 jps - copied from devPIE710.cc + */ + + +#include +#include "motorRecord.h" +#include "motor.h" +#include "motordevCom.h" +#include "drvPIJEDS.h" +#include "epicsExport.h" + +extern struct driver_table PIJEDS_access; + +/* ----------------Create the dsets for devPIJEDS----------------- */ +static struct driver_table *drvtabptr; +static long PIJEDS_init(void *); +static long PIJEDS_init_record(void *); +static long PIJEDS_start_trans(struct motorRecord *); +static RTN_STATUS PIJEDS_build_trans(motor_cmnd, double *, struct motorRecord *); +static RTN_STATUS PIJEDS_end_trans(struct motorRecord *); + +struct motor_dset devPIJEDS = +{ + {8, NULL, (DEVSUPFUN) PIJEDS_init, (DEVSUPFUN) PIJEDS_init_record, NULL}, + motor_update_values, + PIJEDS_start_trans, + PIJEDS_build_trans, + PIJEDS_end_trans +}; + +extern "C" {epicsExportAddress(dset,devPIJEDS);} + +/* --------------------------- program data --------------------- */ + +/* This table is used to define the command types */ +/* WARNING! this must match "motor_cmnd" in motor.h */ + +static msg_types PIJEDS_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 */ + VELOCITY /* JOG_VELOCITY */ +}; + + +static struct board_stat **PIJEDS_cards; + +/* --------------------------- program data --------------------- */ + + +/* initialize device support for PIJEDS stepper motor */ +static long PIJEDS_init(void *arg) +{ + long rtnval; + int after = (int) arg; + + if (after == 0) + { + drvtabptr = &PIJEDS_access; + (drvtabptr->init)(); + } + + rtnval = motor_init_com(after, *drvtabptr->cardcnt_ptr, drvtabptr, &PIJEDS_cards); + return(rtnval); +} + + +/* initialize a record instance */ +static long PIJEDS_init_record(void *arg) +{ + struct motorRecord *mr = (struct motorRecord *) arg; + /* Disable change of direction testing in record support */ + /* This is a closed-loop device */ + mr->ntm = menuYesNoNO; + return(motor_init_record_com(mr, *drvtabptr->cardcnt_ptr, drvtabptr, PIJEDS_cards)); +} + + +/* start building a transaction */ +static long PIJEDS_start_trans(struct motorRecord *mr) +{ + motor_start_trans_com(mr, PIJEDS_cards); + return(OK); +} + + +/* end building a transaction */ +static RTN_STATUS PIJEDS_end_trans(struct motorRecord *mr) +{ + motor_end_trans_com(mr, drvtabptr); + return(OK); +} + + +/* add a part to the transaction */ +static RTN_STATUS PIJEDS_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 PIJEDScontroller *cntrl; + char buff[110]; + int card, maxdigits; + unsigned int size; + double dval, cntrl_units, res; + RTN_STATUS rtnval; + bool send; + + send = true; /* Default to send motor command. */ + rtnval = OK; + buff[0] = '\0'; + + /* Protect against NULL pointer with WRTITE_MSG(GO/STOP_AXIS/GET_INFO, NULL). */ + dval = (parms == NULL) ? 0.0 : *parms; + + rtnval = (RTN_STATUS) motor_start_trans_com(mr, PIJEDS_cards); + + motor_call = &(trans->motor_call); + card = motor_call->card; + + motor_call->type = PIJEDS_table[command]; + + brdptr = (*trans->tabptr->card_array)[card]; + if (brdptr == NULL) + return(rtnval = ERROR); + + cntrl = (struct PIJEDScontroller *) brdptr->DevicePrivate; + res = cntrl->drive_resolution[motor_call->signal]; + cntrl_units = dval; + maxdigits = EDS_MAX_RES; + + if (PIJEDS_table[command] > motor_call->type) + motor_call->type = PIJEDS_table[command]; + + if (trans->state != BUILD_STATE) + return(rtnval = ERROR); + + if (command == PRIMITIVE && mr->init != NULL && strlen(mr->init) != 0) + strcat(motor_call->message, mr->init); + + + switch (command) + { + case MOVE_ABS: + case MOVE_REL: + case HOME_FOR: + case HOME_REV: + case JOG: + if (strlen(mr->prem) != 0) + { + strcat(motor_call->message, mr->prem); + rtnval = motor_end_trans_com(mr, drvtabptr); + rtnval = (RTN_STATUS) motor_start_trans_com(mr, PIJEDS_cards); + motor_call->type = PIJEDS_table[command]; + } + if (strlen(mr->post) != 0) + motor_call->postmsgptr = (char *) &mr->post; + break; + + default: + break; + } + + + switch (command) + { + case MOVE_ABS: + sprintf(buff, "set,#,%.*f", maxdigits, (cntrl_units * res)); + break; + + case MOVE_REL: + send = false; + break; + + case HOME_FOR: + case HOME_REV: + send = false; + break; + + case LOAD_POS: + send = false; + break; + + case SET_VEL_BASE: + send = false; /* DC motor; not base velocity. */ + break; + + case SET_VELOCITY: + sprintf(buff, "sr,#,%.*f", maxdigits, (cntrl_units * res)); + break; + + case ENABLE_TORQUE: + strcpy(buff, "cl,#,1"); + break; + + case DISABL_TORQUE: + strcpy(buff, "cl,#,0"); + break; + + case SET_ACCEL: + /* The PIJEDS does not support acceleration commands. */ + send = false; + break; + + case GO: + /* The PIJEDS starts moving immediately on move commands + * Must send a command for driver expects a response */ + strcpy(buff, "stat,#"); + break; + + case PRIMITIVE: + case GET_INFO: + /* These commands are not actually done by sending a message, but + rather they will indirectly cause the driver to read the status + of all motors */ + send=false; + break; + + case STOP_AXIS: + /* No stop command available - use move relative 0 */ + send = false; + break; + + case JOG_VELOCITY: + case JOG: + sprintf(buff, "sr,#,%.*f", maxdigits, (cntrl_units * res)); + break; + + case SET_PGAIN: + send = false; + break; + case SET_IGAIN: + send = false; + break; + case SET_DGAIN: + send = false; + break; + + case SET_HIGH_LIMIT: + case SET_LOW_LIMIT: + case SET_ENC_RATIO: + trans->state = IDLE_STATE; /* No command sent to the controller. */ + send = false; + break; + + default: + send = false; + rtnval = ERROR; + } + + size = strlen(buff); + if (send == false) + return(rtnval); + else if (size > sizeof(buff) || (strlen(motor_call->message) + size) > MAX_MSG_SIZE) + errlogMessage("PIJEDS_build_trans(): buffer overflow.\n"); + else + { + strcat(motor_call->message, buff); + rtnval = motor_end_trans_com(mr, drvtabptr); + } + return(rtnval); +} diff --git a/motorApp/PiJenaSrc/devPIJena.dbd b/motorApp/PiJenaSrc/devPIJena.dbd new file mode 100644 index 00000000..63804aeb --- /dev/null +++ b/motorApp/PiJenaSrc/devPIJena.dbd @@ -0,0 +1,7 @@ +# Piezosystem jena motor controllers +device(motor,VME_IO,devPIJEDS,"PIJEDS") +driver(drvPIJEDS) +registrar(PIJEDSmotorRegister) +variable(drvPIJEDSdebug) + + diff --git a/motorApp/PiJenaSrc/drvPIJEDS.cc b/motorApp/PiJenaSrc/drvPIJEDS.cc new file mode 100644 index 00000000..ecd9fcf4 --- /dev/null +++ b/motorApp/PiJenaSrc/drvPIJEDS.cc @@ -0,0 +1,711 @@ +/* +FILENAME... drvPIJEDS.cc +USAGE... Motor record driver level support for piezosystem jena + GmbH & Co. E-516 motor controller. + +Version: $Revision: 1.1 $ +Modified By: $Author: sullivan $ +Last Modified: $Date: 2007-06-14 15:56:59 $ +*/ + +/* + * Original Author: Joe Sullivan + * Date: 6/07 + * + * Experimental Physics and Industrial Control System (EPICS) + * + * Copyright 1991, the Regents of the University of California, + * and the University of Chicago Board of Governors. + * + * This software was produced under U.S. Government contracts: + * (W-7405-ENG-36) at the Los Alamos National Laboratory, + * and (W-31-109-ENG-38) at Argonne National Laboratory. + * + * Initial development by: + * The Controls and Automation Group (AT-8) + * Ground Test Accelerator + * Accelerator Technology Division + * Los Alamos National Laboratory + * + * Co-developed with + * The Controls and Computing Group + * Accelerator Systems Division + * Advanced Photon Source + * Argonne National Laboratory + * + * Modification Log: + * ----------------- + * .01 03/26/07 jps - copied from drvPIC710.cc tested on PI VER "DSP V3.11,MCU V5" + */ + +/* +DESIGN LIMITATIONS... + 1 - Like all controllers, the PIJEDS must be powered-on when EPICS is first + booted up. +*/ + +#include +#include +#include +#include +#include "motorRecord.h" +#include "motor.h" +#include "drvPIJEDS.h" +#include "epicsExport.h" + +#define GET_IDENT "" + +#define BUFF_SIZE 100 /* Maximum length of string to/from PIJEDS */ + +/*----------------debugging-----------------*/ +#ifdef __GNUG__ + #ifdef DEBUG + #define Debug(l, f, args...) { if(l<=drvPIJEDSdebug) printf(f,## args); } + #else + #define Debug(l, f, args...) + #endif +#else + #define Debug() +#endif +volatile int drvPIJEDSdebug = 0; +extern "C" {epicsExportAddress(int, drvPIJEDSdebug);} + +/* --- Local data. --- */ +int PIJEDS_num_cards = 0; +static char *PIJEDS_axis[] = {"0", "1", "2", "3", "4", "5"}; + +/* Command Information - used by set_status() */ +#define EDS_CMNDS_MAX 3 +#define EDS_POS 0 +#define EDS_STATUS 1 +#define EDS_SLEW 2 + +#define READ_POS "mess,#" /* Read position command */ +#define READ_STATUS "stat,#" /* Read Motor Status */ +#define READ_SLEW "sr,#" /* Read Slew Velocity V/ms */ + +static char *EDS_CMNDS[] = {READ_POS, READ_STATUS, READ_SLEW}; + +/* See fillCmndInfo() */ +static struct cmndInfo_struct { + char sendStr[10]; /* Command String */ + char searchStr[3]; /* Partial command string to check reply */ + int dataIndex; /* Index into reply for data */ +} cmndInfo[EDS_CMNDS_MAX]; + +static unsigned long fdbk_tolerance; /* Divisor to shift position - for DONE */ + +/* Local data required for every driver; see "motordrvComCode.h" */ +#include "motordrvComCode.h" + + +/*----------------functions-----------------*/ +static int recv_mess(int, char *, int); +static RTN_STATUS send_mess(int, char const *, char *); +static int set_status(int, int); +static long report(int); +static long init(); +static int motor_init(); +static void fillCmndInfo(); +static void query_done(int, int, struct mess_node *); + +/*----------------functions-----------------*/ + +struct driver_table PIJEDS_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, + NULL, + &initialized, + PIJEDS_axis +}; + +struct +{ + long number; + long (*report) (int); + long (*init) (void); +} drvPIJEDS = {2, report, init}; + +extern "C" {epicsExportAddress(drvet, drvPIJEDS);} + +static struct thread_args targs = {SCAN_RATE, &PIJEDS_access, 0.0}; + +/********************************************************* + * Print out driver status report + *********************************************************/ +static long report(int level) +{ + int card; + + if (PIJEDS_num_cards <=0) + printf(" No PIJEDS controllers configured.\n"); + else + { + for (card = 0; card < PIJEDS_num_cards; card++) + { + struct controller *brdptr = motor_state[card]; + + if (brdptr == NULL) + printf(" PIJEDS controller %d connection failed.\n", card); + else + { + struct PIJEDScontroller *cntrl; + + cntrl = (struct PIJEDScontroller *) brdptr->DevicePrivate; + printf(" PIJEDS controller #%d, port=%s, id: %s \n", card, + cntrl->asyn_port, brdptr->ident); + } + } + } + return(OK); +} + + +static long init() +{ + /* + * We cannot call motor_init() here, because that function can do GPIB I/O, + * and hence requires that the drvGPIB have already been initialized. + * That cannot be guaranteed, so we need to call motor_init from device + * support + */ + /* Check for setup */ + if (PIJEDS_num_cards <= 0) + { + Debug(1, "init(): PIJEDS driver disabled. PIJEDSSetup() missing from startup script.\n"); + } + return((long) 0); +} + + +static void query_done(int card, int axis, struct mess_node *nodeptr) +{ +} + + +/******************************************************************************** +* * +* FUNCTION NAME: set_status * +* * +* LOGIC: * +* Initialize. * +* Send "Moving Status" query. * +* Read response. * +* IF normal response to query. * +* Set communication status to NORMAL. * +* ELSE * +* IF communication status is NORMAL. * +* Set communication status to RETRY. * +* NORMAL EXIT. * +* ELSE * +* Set communication status error. * +* ERROR EXIT. * +* ENDIF * +* ENDIF * +* * +* IF "Moving Status" indicates any motion (i.e. status != 0). * +* Clear "Done Moving" status bit. * +* ELSE * +* Set "Done Moving" status bit. * +* ENDIF * +* * +* * +********************************************************************************/ + +static int set_status(int card, int signal) +{ + struct PIJEDScontroller *cntrl; + struct mess_node *nodeptr; + struct mess_info *motor_info; + struct motorRecord *mr; + /* Message parsing variables */ + struct cmndInfo_struct *pInfo; + char buff[BUFF_SIZE]; + char *pdata; + int rtn_state; + EDS_Status_Reg statusReg; + epicsInt32 motorData; + unsigned long posDelta; + bool plusdir, ls_active, plusLS, minusLS; + bool readOK; + msta_field status; + + cntrl = (struct PIJEDScontroller *) motor_state[card]->DevicePrivate; + motor_info = &(motor_state[card]->motor_info[signal]); + nodeptr = motor_info->motor_motion; + if (nodeptr != NULL) + mr = (struct motorRecord *) nodeptr->mrecord; + else + mr = NULL; + status.All = motor_info->status.All; + + recv_mess(card, buff, FLUSH); + + readOK = false; + + // Read controller status word + pInfo = &cmndInfo[EDS_STATUS]; + send_mess(card, pInfo->sendStr, PIJEDS_axis[signal]); + if (recv_mess(card, buff, 1) && (pdata=strstr(buff,pInfo->searchStr))) + { + // sscanf(pdata+pInfo->dataIndex, "%d", (int *)&statusReg.All); + statusReg.All = atoi(pdata+pInfo->dataIndex); + Debug(2, "set_status(): statusStr: %s, statusReg=0x%x\n", pdata, statusReg.All); + + // Read motor position + pInfo = &cmndInfo[EDS_POS]; + send_mess(card, pInfo->sendStr, PIJEDS_axis[signal]); + if (recv_mess(card, buff, 1) && (pdata=strstr(buff,pInfo->searchStr))) + { + motorData = NINT(atof(pdata+pInfo->dataIndex) / cntrl->drive_resolution[signal]); + Debug(2, "set_status(): posString: %s, posData=%d\n", pdata, motorData); + readOK = true; + } + else + Debug(1, "set_status(): posString: ERROR!\n"); + + } + else + Debug(1, "set_status(): statusString: ERROR!\n"); + + + if (readOK) + { + cntrl->status = NORMAL; + status.Bits.CNTRL_COMM_ERR = 0; + } + else + { + if (cntrl->status == NORMAL) + { + cntrl->status = RETRY; + rtn_state = OK; + goto exit; + } + else + { + cntrl->status = COMM_ERR; + status.Bits.CNTRL_COMM_ERR = 1; + status.Bits.RA_PROBLEM = 1; + rtn_state = 1; + goto exit; + } + } + + /* No direct DONE status on the EDS controller + * DONE is derived from delta position test */ + status.Bits.RA_DONE = 0; + + status.Bits.RA_HOME = status.Bits.RA_DONE; + status.Bits.EA_POSITION = (statusReg.Bits.closeLoop) ? 1 : 0; /* Torgue disabled flag */ + + /* No Limit switches */ + ls_active = plusLS = minusLS = false; + + // When comparing feedback position - allow for sloppyness + posDelta = abs(motorData-motor_info->position); + Debug(5, "set_status(): deltaPos: %ld\n", posDelta); + + /* Reference position is not available so + * widen the 'no motion' test because of encoder + * jitter. */ + + // if (motorData == motor_info->position) + if (posDelta < fdbk_tolerance) + { + if (motor_info->no_motion_count) + { + status.Bits.RA_DONE = 1; + status.Bits.RA_HOME = status.Bits.RA_DONE; + } + + if (nodeptr != 0) /* Increment counter only if motor is moving. */ + motor_info->no_motion_count++; + } + else + { + status.Bits.RA_DIRECTION = (motorData >= motor_info->position) ? 1 : 0; + motor_info->no_motion_count = 0; + } + + motor_info->position = motor_info->encoder_position = motorData; + + + plusdir = (status.Bits.RA_DIRECTION) ? true : false; + + /* Set limit switch error indicators. */ + if (plusLS == true) + { + status.Bits.RA_PLUS_LS = 1; + if (plusdir == true) + ls_active = true; + } + else + status.Bits.RA_PLUS_LS = 0; + + if (minusLS == true) + { + status.Bits.RA_MINUS_LS = 1; + if (plusdir == false) + ls_active = true; + } + else + status.Bits.RA_MINUS_LS = 0; + + /* encoder status */ + status.Bits.EA_SLIP = 0; + status.Bits.EA_SLIP_STALL = 0; + status.Bits.EA_HOME = 0; + + status.Bits.RA_PROBLEM = 0; + + /* Parse motor velocity? */ + /* NEEDS WORK */ + + motor_info->velocity = 0; + + // if (!status.Bits.RA_DIRECTION) + // motor_info->velocity *= -1; + + rtn_state = (!motor_info->no_motion_count || ls_active == true || + status.Bits.RA_DONE | status.Bits.RA_PROBLEM) ? 1 : 0; + + /* Test for post-move string. */ + if ((status.Bits.RA_DONE || ls_active == true) && nodeptr != 0 && + nodeptr->postmsgptr != 0) + { + strcpy(buff, nodeptr->postmsgptr); + send_mess(card, buff, (char) NULL); + nodeptr->postmsgptr = NULL; + } + +exit: + motor_info->status.All = status.All; + return(rtn_state); +} + + +/*****************************************************/ +/* send a message to the PIJEDS board */ +/* send_mess() */ +/*****************************************************/ +static RTN_STATUS send_mess(int card, char const *com, char *name) +{ + char local_buff[MAX_MSG_SIZE]; + char *pbuff; + struct PIJEDScontroller *cntrl; + int comsize, namesize; + size_t nwrite; + + comsize = (com == NULL) ? 0 : strlen(com); + namesize = (name == NULL) ? 0 : strlen(name); + + if ((comsize + namesize) > MAX_MSG_SIZE) + { + errlogMessage("drvPIJEDS.cc:send_mess(); message size violation.\n"); + return(ERROR); + } + // Allow empty message strings - returns version info */ + // else if (comsize == 0) /* Normal exit on empty input message. */ + // return(OK); + + if (!motor_state[card]) + { + errlogPrintf("drvPIJEDS.cc:send_mess() - invalid card #%d\n", card); + return(ERROR); + } + + local_buff[0] = (char) NULL; /* Terminate local buffer. */ + + if (name == NULL) + strcat(local_buff, com); /* Make a local copy of the string. */ + else + { + strcpy(local_buff, com); + pbuff = strchr(local_buff, '#'); + if (pbuff != NULL) + *pbuff = *name; + else + Debug(1, "send_mess(): NAME ERROR: message = %s\n", local_buff); + } + + Debug(3, "send_mess(): message = %s\n", local_buff); + + cntrl = (struct PIJEDScontroller *) motor_state[card]->DevicePrivate; + pasynOctetSyncIO->write(cntrl->pasynUser, local_buff, strlen(local_buff), + COMM_TIMEOUT, &nwrite); + + return(OK); +} + + +/*****************************************************/ +/* receive a message from the PIJEDS board */ +/* recv_mess() */ +/*****************************************************/ +static int recv_mess(int card, char *com, int flag) +{ + struct PIJEDScontroller *cntrl; + size_t nread = 0; + asynStatus status = asynError; + int eomReason; + + /* Check that card exists */ + if (!motor_state[card]) + return(ERROR); + + cntrl = (struct PIJEDScontroller *) motor_state[card]->DevicePrivate; + + if (flag == FLUSH) + pasynOctetSyncIO->flush(cntrl->pasynUser); + else + status = pasynOctetSyncIO->read(cntrl->pasynUser, com, BUFF_SIZE, + COMM_TIMEOUT, &nread, &eomReason); + + if ((status != asynSuccess) || (nread <= 0)) + { + com[0] = '\0'; + nread = 0; + } + + Debug(3, "recv_mess(): message = \"%s\"\n", com); + return(nread); +} + + +/*****************************************************/ +/* Setup system configuration */ +/* PIJEDSSetup() */ +/*****************************************************/ +RTN_STATUS +PIJEDSSetup(int num_cards, /* maximum number of controllers in system. */ + int scan_rate) /* polling rate - 1/60 sec units. */ +{ + int itera; + + if (num_cards < 1 || num_cards > PIJEDS_NUM_CARDS) + PIJEDS_num_cards = PIJEDS_NUM_CARDS; + else + PIJEDS_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 motor_state structures. Note this must be done + * before PIJEDSConfig is called, so it cannot be done in motor_init() + * This means that we must allocate space for a card without knowing + * if it really exists, which is not a serious problem + */ + motor_state = (struct controller **) malloc(PIJEDS_num_cards * + sizeof(struct controller *)); + + for (itera = 0; itera < PIJEDS_num_cards; itera++) + motor_state[itera] = (struct controller *) NULL; + + return(OK); +} + + +/*****************************************************/ +/* Configure a controller */ +/* PIJEDSConfig() */ +/*****************************************************/ +RTN_STATUS +PIJEDSConfig(int card, /* card being configured */ + const char *name, /* asyn port name */ + int addr) /* asyn address (GPIB) */ +{ + struct PIJEDScontroller *cntrl; + + if (card < 0 || card >= PIJEDS_num_cards) + return(ERROR); + + motor_state[card] = (struct controller *) malloc(sizeof(struct controller)); + motor_state[card]->DevicePrivate = malloc(sizeof(struct PIJEDScontroller)); + cntrl = (struct PIJEDScontroller *) motor_state[card]->DevicePrivate; + + strcpy(cntrl->asyn_port, name); + cntrl->asyn_address = addr; + return(OK); +} + + +/*****************************************************/ +/* initialize all software and hardware */ +/* This is called from the initialization routine in */ +/* device support. */ +/* motor_init() */ +/*****************************************************/ +static int motor_init() +{ + struct controller *brdptr; + struct PIJEDScontroller *cntrl; + int card_index, motor_index; + char buff[BUFF_SIZE], *pbuff; + int total_axis; + int status; + int version; + bool online; + asynStatus success_rtn; + static const char output_terminator[] = EDS_OUT_EOS; + static const char input_terminator[] = EDS_IN_ETX; + + initialized = true; /* Indicate that driver is initialized. */ + + /* Check for setup */ + if (PIJEDS_num_cards <= 0) + return(ERROR); + + /* Fill out EDS command string information - used by set_status() */ + fillCmndInfo(); + + for (card_index = 0; card_index < PIJEDS_num_cards; card_index++) + { + if (!motor_state[card_index]) + continue; + + brdptr = motor_state[card_index]; + brdptr->ident[0] = (char) NULL; /* No controller identification message. */ + brdptr->cmnd_response = true; + total_cards = card_index + 1; + cntrl = (struct PIJEDScontroller *) brdptr->DevicePrivate; + + status = version = 0; + + /* Initialize communications channel */ + success_rtn = pasynOctetSyncIO->connect(cntrl->asyn_port, 0, + &cntrl->pasynUser, NULL); + if (success_rtn == asynSuccess) + { + int retry = 0; + + pasynOctetSyncIO->setOutputEos(cntrl->pasynUser, output_terminator, + strlen(output_terminator)); + pasynOctetSyncIO->setInputEos(cntrl->pasynUser, input_terminator, + strlen(input_terminator)); + + /* Send a message to the board, see if it exists */ + /* flush any junk at input port - should not be any data available */ + pasynOctetSyncIO->flush(cntrl->pasynUser); + + /* Assure that Controller is ONLINE */ + do + { + online = false; + /* Set Controller to ONLINE mode */ + send_mess(card_index, GET_IDENT, (char) NULL); + if ((status = recv_mess(card_index, buff, 1))) + online = (strstr(buff,"DSM")) ? true : false; + else + retry++; + } while (online == false && retry < 3); + + } + + if (success_rtn == asynSuccess && online == true) + { + /* Parse out EDS revision (3 decimal places) and convert to int */ + if ((pbuff = strchr(buff, 'V'))) + version = NINT(atof(pbuff+1) * 1000); + else + version = 0; + + strcpy(brdptr->ident, buff); + brdptr->localaddr = (char *) NULL; + brdptr->motor_in_motion = 0; + + /* Check for supported EDS versions */ + if (version >= 1959) + cntrl->versionSupport = true; + else + cntrl->versionSupport = false; + + /* Determine # of axes. Request stage name. See if it responds */ + for (total_axis = 0; total_axis < EDS_MAX_MOTORS; total_axis++) + { + send_mess(card_index, READ_POS, PIJEDS_axis[total_axis]); + status = recv_mess(card_index, buff, 1); + if (strstr(buff,"not present")) + break; + } + brdptr->total_axis = total_axis; + + /* fdbk_tolerance = 10^^(MAX_RES - 1) */ + /* Used in set_status() to calculate DONE/NO_MOTION */ + fdbk_tolerance = (unsigned long)pow(10.0,(double)(EDS_MAX_RES-1)); + + for (motor_index = 0; motor_index < total_axis; 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; + brdptr->motor_info[motor_index].motor_motion = NULL; + /* PIJEDS has DC motor support only */ + motor_info->encoder_present = YES; + motor_info->status.Bits.EA_PRESENT = 1; + motor_info->pid_present = NO; + motor_info->status.Bits.GAIN_SUPPORT = 1; + + cntrl->drive_resolution[motor_index] = 1.0/pow(10.0,(double)EDS_MAX_RES); + + set_status(card_index, motor_index); /* Read status of each motor */ + } + } + else + motor_state[card_index] = (struct controller *) NULL; + } + + 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; + + epicsThreadCreate((char *) "PIJEDS_motor", epicsThreadPriorityMedium, + epicsThreadGetStackSize(epicsThreadStackMedium), + (EPICSTHREADFUNC) motor_task, (void *) &targs); + + return(OK); +} + + +static void fillCmndInfo() +{ + int index; + struct cmndInfo_struct *pInfo = cmndInfo; + char **pCmndStr = EDS_CMNDS; + + for (index = 0; index < EDS_CMNDS_MAX; index++, pInfo++, pCmndStr++) + { + strcpy(pInfo->sendStr,*pCmndStr); /* Command String */ + strncpy(pInfo->searchStr,*pCmndStr,2); /* Partial Cmnd to check reply */ + pInfo->dataIndex = strlen(*pCmndStr) + 1; /* Index to reply data */ + } + +} + diff --git a/motorApp/PiJenaSrc/drvPIJEDS.h b/motorApp/PiJenaSrc/drvPIJEDS.h new file mode 100644 index 00000000..22937017 --- /dev/null +++ b/motorApp/PiJenaSrc/drvPIJEDS.h @@ -0,0 +1,85 @@ +/* File: drvPIJEDS.h */ + + +/* Device Driver Support definitions for motor */ +/* + * Original Author: Ron Sluiter + * Current Author: Joe Sullivan + * Date: 09/20/2005 + * + * Modification Log: + * ----------------- + * .00 09/13/2006 jps copied from drvPIC838.h + */ + +#ifndef INCdrvPIJEDSh +#define INCdrvPIJEDSh 1 + +#include "motordrvCom.h" +#include "asynDriver.h" +#include "asynDriver.h" +#include "asynOctetSyncIO.h" + +#define COMM_TIMEOUT 2 /* Timeout in seconds. */ +#define EDS_MAX_RES 3 /* Position resolution (significant digits) */ + +#define EDS_OUT_EOS "\r" /* Command End-Of-Line = CR (0x13) */ +#define EDS_IN_STX "\023" /* Reply Start (frame character) */ +#define EDS_IN_ETX "\021" /* Reply End (framing Character) */ + +#define EDS_VERSION 1959 /* Driver tested against EDS DSM V1.959 */ +#define EDS_MAX_MOTORS 6 /* maximum motors per controller */ +#define PIJEDS_NUM_CARDS 10 /* Maximum number of support controllers */ + +struct PIJEDScontroller +{ + asynUser *pasynUser; /* asynUser structure */ + int asyn_address; /* Use for GPIB or other address with asyn */ + CommStatus status; /* Controller communication status. */ + double drive_resolution[EDS_MAX_MOTORS]; + bool versionSupport; /* Track supported Versions - include in Report */ + char asyn_port[80]; /* asyn port name */ +}; + +/* Types of position feedback */ +#define EDS_FDBK_NONE 0 +#define EDS_FDBK_STRAIN 1 +#define EDS_FDBK_CAPACITIVE 2 /* Typical */ +#define EDS_FDBK_INDUCTIVE 3 + +/* Controller Status Word */ +typedef union +{ + epicsUInt16 All; + struct + { +#ifdef MSB_First + unsigned int nabyte :8; /* 8-15 */ + unsigned int closeLoop :1; /* 7 - Closed Loop Mode */ + unsigned int piezoDecontrol :1; /* 6 - Piezo Voltage Decontroled */ + unsigned int na5 :1; /* 5 - NA. */ + unsigned int openLoop :1; /* 4 - Open Loop Mode */ + unsigned int na3 :1; /* 3 NA */ + unsigned int fdbkType :2; /* 1&2 - Feedback Type - EDS_FDBK_nnnnn */ + unsigned int motorExist :1; /* 0 - Motor plugged into controller */ + +#else + unsigned int motorExist :1; /* 0 - Motor plugged into controller */ + unsigned int fdbkType :2; /* 1&2 - Feedback Type - EDS_FDBK_nnnnn */ + unsigned int na3 :1; /* 3 NA */ + unsigned int openLoop :1; /* 4 - Open Loop Mode */ + unsigned int na5 :1; /* 5 - NA. */ + unsigned int piezoDecontrol :1; /* 6 - Piezo Voltage Decontroled */ + unsigned int closeLoop :1; /* 7 - Closed Loop Mode */ + unsigned int nabyte :8; /* 8-15 */ + +#endif + } Bits; +} EDS_Status_Reg; + + +/* Function prototypes. */ +extern RTN_STATUS PIJEDSSetup(int, int); +extern RTN_STATUS PIJEDSConfig(int, const char *, int); + +#endif /* INCdrvPIJEDSh */