/** Creates a new SMC100Controller object.
* \param[in] portName The name of the asyn port that will be created for this driver
* \param[in] SMC100PortName The name of the drvAsynSerialPort that was created previously to connect to the SMC100 controller
* \param[in] numAxes The number of axes that this controller supports
* \param[in] movingPollPeriod The time between polls when any axis is moving
* \param[in] idlePollPeriod The time between polls when no axis is moving
*/
SMC100Controller::SMC100Controller(const char *portName, const char *SMC100PortName, int numAxes,
double movingPollPeriod, double idlePollPeriod, double stepSize)
: asynMotorController(portName, numAxes, NUM_SMC100_PARAMS,
0, // No additional interfaces beyond those in base class
0, // No additional callback interfaces beyond those in base class
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0) // Default priority and stack size
{
int axis;
asynStatus status;
SMC100Axis *pAxis;
static const char *functionName = "SMC100Controller::SMC100Controller";
/* Connect to SMC100 controller */
status = pasynOctetSyncIO->connect(SMC100PortName, 0, &pasynUserController_, NULL);
if (status) {
asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
"%s: cannot connect to SMC100 controller\n",
functionName);
}
for (axis=0; axis<numAxes; axis++) {
//for (axis=1; axis < (numAxes + 1); axis++) {
pAxis = new SMC100Axis(this, axis, stepSize);
}
startPoller(movingPollPeriod, idlePollPeriod, 2);
}
/** Creates a new MMC100Controller object.
* \param[in] portName The name of the asyn port that will be created for this driver
* \param[in] MMC100PortName The name of the drvAsynIPPPort that was created previously to connect to the MMC100 controller
* \param[in] numAxes The number of axes that this controller supports
* \param[in] movingPollPeriod The time between polls when any axis is moving
* \param[in] idlePollPeriod The time between polls when no axis is moving
*/
MMC100Controller::MMC100Controller(const char *portName, const char *MMC100PortName, int numAxes,
double movingPollPeriod, double idlePollPeriod)
: asynMotorController(portName, numAxes, NUM_MMC100_PARAMS,
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask,
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask,
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0) // Default priority and stack size
{
int axis;
asynStatus status;
MMC100Axis *pAxis;
static const char *functionName = "MMC100Controller::MMC100Controller";
unitScale_ = MMC100_UNIT_SCALE;
if (!addToList(portName, this)) {
printf("%s:%s: Init failed", driverName, portName);
return;
}
printf("Idle: %f moving: %f\n", idlePollPeriod_, movingPollPeriod_);
idlePollPeriod_ = idlePollPeriod;
movingPollPeriod_ = movingPollPeriod;
timeout_ = MMC100_TIMEOUT;
homing_axis_ = false;
/* Connect to MMC100 controller */
status = pasynOctetSyncIO->connect(MMC100PortName, 0, &pasynUser_, NULL);
if (status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: cannot connect to MMC100 controller\n",
driverName, functionName);
}
status = pasynOctetSyncIO->setInputEos(pasynUser_, "\n\r", 2);
if (status) {
asynPrint(pasynUser_, ASYN_TRACE_ERROR|ASYN_TRACE_FLOW,
"%s: Unable to set input EOS on %s: %s\n",
functionName, MMC100PortName, pasynUser_->errorMessage);
}
status = pasynOctetSyncIO->setOutputEos(pasynUser_, "\n\r", 2);
if (status) {
asynPrint(pasynUser_, ASYN_TRACE_ERROR|ASYN_TRACE_FLOW,
"%s: Unable to set output EOS on %s: %s\n",
functionName, MMC100PortName, pasynUser_->errorMessage);
}
// Create the axis objects
for (axis=0; axis<numAxes; axis++) {
pAxis = new MMC100Axis(this, axis);
pAxis->check_error();
}
startPoller(movingPollPeriod/1000., idlePollPeriod/1000., 2);
}
////////////////////////////////////////////////////////
//! @ImsMDrivePlusMotorController()
//! Constructor
//! Driver assumes only 1 axis configured per controller for now...
//!
//! @param[in] motorPortName Name assigned to the port created to communicate with the motor
//! @param[in] IOPortName Name assigned to the asyn IO port, name that was assigned in drvAsynIPPortConfigure()
//! @param[in] devName Name of device (DN) assigned to motor axis in MCode, the device name is prepended to the MCode command to support Party Mode (PY) multidrop communication setup
//! set to empty string "" if no device name needed/not using Party Mode
//! @param[in] movingPollPeriod Moving polling period in milliseconds
//! @param[in] idlePollPeriod Idle polling period in milliseconds
////////////////////////////////////////////////////////
ImsMDrivePlusMotorController::ImsMDrivePlusMotorController(const char *motorPortName, const char *IOPortName, const char *devName, double movingPollPeriod, double idlePollPeriod)
: asynMotorController(motorPortName, NUM_AXES, NUM_IMS_PARAMS,
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask,
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask,
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0), // Default priority and stack size
pAsynUserIMS(0)
{
static const char *functionName = "ImsMDrivePlusMotorController()";
asynStatus status;
ImsMDrivePlusMotorAxis *pAxis;
// asynMotorController constructor calloc's memory for array of axis pointers
pAxes_ = (ImsMDrivePlusMotorAxis **)(asynMotorController::pAxes_);
// copy names
strcpy(motorName, motorPortName);
// setup communication
status = pasynOctetSyncIO->connect(IOPortName, 0, &pAsynUserIMS, NULL);
if (status != asynSuccess) {
printf("\n\n%s:%s: ERROR connecting to Controller's IO port=%s\n\n", DRIVER_NAME, functionName, IOPortName);
// TODO would be good to implement exceptions
// TODO THROW_(SmarActMCSException(MCSConnectionError, "SmarActMCSController: unable to connect serial channel"));
}
// write version, cannot use asynPrint() in constructor since controller (motorPortName) hasn't been created yet
printf("%s:%s: motorPortName=%s, IOPortName=%s, devName=%s \n", DRIVER_NAME, functionName, motorPortName, IOPortName, devName);
// init
pasynOctetSyncIO->setInputEos(pAsynUserIMS, "\n", 1);
pasynOctetSyncIO->setOutputEos(pAsynUserIMS, "\r\n", 2);
// Create controller-specific parameters
createParam(ImsMDrivePlusSaveToNVMControlString, asynParamInt32, &ImsMDrivePlusSaveToNVM_);
createParam(ImsMDrivePlusLoadMCodeControlString, asynParamOctet, &this->ImsMDrivePlusLoadMCode_);
createParam(ImsMDrivePlusClearMCodeControlString, asynParamOctet, &this->ImsMDrivePlusClearMCode_);
// Check the validity of the arguments and init controller object
initController(devName, movingPollPeriod, idlePollPeriod);
// Create axis
// Assuming single axis per controller the way drvAsynIPPortConfigure( "M06", "ts-b34-nw08:2101", 0, 0 0 ) is called in st.cmd script
pAxis = new ImsMDrivePlusMotorAxis(this, 0);
pAxis = NULL; // asynMotorController constructor tracking array of axis pointers
// read home and limit config from S1-S4
readHomeAndLimitConfig();
startPoller(movingPollPeriod, idlePollPeriod, 2);
}
/** Creates a new AG_CONEXController object.
* \param[in] portName The name of the asyn port that will be created for this driver
* \param[in] serialPortName The name of the drvAsynSerialPort that was created previously to connect to the CONEX controller
* \param[in] numAxes The number of axes that this controller supports
* \param[in] movingPollPeriod The time between polls when any axis is moving
* \param[in] idlePollPeriod The time between polls when no axis is moving
*/
AG_CONEXController::AG_CONEXController(const char *portName, const char *serialPortName, int controllerID,
double movingPollPeriod, double idlePollPeriod)
: asynMotorController(portName, 1, NUM_AG_CONEX_PARAMS,
0, // No additional interfaces beyond those in base class
0, // No additional callback interfaces beyond those in base class
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0), // Default priority and stack size
controllerID_(controllerID)
{
asynStatus status;
static const char *functionName = "AG_CONEXController::AG_CONEXController";
/* Connect to CONEX controller */
status = pasynOctetSyncIO->connect(serialPortName, 0, &pasynUserController_, NULL);
if (status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s: cannot connect to CONEX controller\n",
functionName);
return;
}
// Flush any characters that controller has, read firmware version
sprintf(outString_, "%dVE", controllerID_);
status = writeReadController();
if (status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s: cannot read version information from AG_CONEX controller\n",
functionName);
return;
}
strcpy(controllerVersion_, &inString_[4]);
// Create the axis object
new AG_CONEXAxis(this);
startPoller(movingPollPeriod, idlePollPeriod, 2);
}
/** Creates a new C300Controller object.
* \param[in] portName The name of the asyn port that will be created for this driver
* \param[in] C300PortName The name of the drvAsynIPPPort that was created previously to connect to the C300 controller
* \param[in] numAxes The number of axes that this controller supports
* \param[in] movingPollPeriod The time between polls when any axis is moving
* \param[in] idlePollPeriod The time between polls when no axis is moving
*/
C300Controller::C300Controller(const char *portName, const char *C300PortName, int numAxes,
double movingPollPeriod, double idlePollPeriod)
: asynMotorController(portName, numAxes, NUM_C300_PARAMS,
asynUInt32DigitalMask,
asynUInt32DigitalMask,
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0) // Default priority and stack size
{
int axis;
asynStatus status;
C300Axis *pAxis;
static const char *functionName = "C300Controller";
/* Connect to C300 controller */
status = pasynOctetSyncIO->connect(C300PortName, 0, &pasynUserC300_, NULL);
if (status) {
asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: cannot connect to C300 controller\n",
driverName, functionName);
}
// Unlock the controller
sprintf(outString_, "SYS:PASS:CEN \"nPoint\"");
writeController();
// get controller id, firmware version and range?
// Wait a short while so that any responses to the above commands have time to arrive so we can flush
// them in the next writeReadController()
//epicsThreadSleep(0.5);
// Create the axis objects
for (axis=0; axis<numAxes; axis++) {
pAxis = new C300Axis(this, axis);
}
startPoller(movingPollPeriod, idlePollPeriod, 2);
}
/** Creates a new ddriveController object.
* \param[in] portName The name of the asyn port that will be created for this driver
* \param[in] ddrivePortName The name of the drvAsynIPPPort that was created previously to connect to the ddrive controller
* \param[in] numAxes The number of axes that this controller supports
* \param[in] movingPollPeriod The time between polls when any axis is moving
* \param[in] idlePollPeriod The time between polls when no axis is moving
*/
ddriveController::ddriveController(const char *portName, const char *ddrivePortName, int numAxes,
double movingPollPeriod, double idlePollPeriod)
: asynMotorController(portName, numAxes, NUM_DDRIVE_PARAMS,
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask,
asynInt32Mask | asynFloat64Mask | asynUInt32DigitalMask,
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0) // Default priority and stack size
{
int axis;
asynStatus status;
//ddriveAxis *pAxis;
queryRate_ = 1;
position_move_timeout_ = DDRIVE_MOVE_TIMEOUT;
dd_param_count_ = NUM_DDRIVE_CONTROLLER_PARAMS;
idlePollPeriod_ = idlePollPeriod;
movingPollPeriod_ = movingPollPeriod;
timeout_ = DDRIVE_TIMEOUT;
ddparams_ = new DDParam[NUM_DDRIVE_CONTROLLER_PARAMS];
// R+W parameters
// command to send, asyn string, type, parameter index, poll, global, service mode)
createDDParam(DD_PARAM_CMD_KTEMP, DD_PARAM_STR_KTEMP, asynParamFloat64, ¶m_ktemp_);
createDDParam(DD_PARAM_CMD_ROHM, DD_PARAM_STR_ROHM, asynParamInt32, ¶m_rohm_);
createDDParam(DD_PARAM_CMD_RGVER, DD_PARAM_STR_RGVER, asynParamInt32, ¶m_rgver_);
createDDParam(DD_PARAM_CMD_FENABLE, DD_PARAM_STR_FENABLE, asynParamInt32, ¶m_fenable_);
createDDParam(DD_PARAM_CMD_SR, DD_PARAM_STR_SR, asynParamFloat64, ¶m_sr_);
createDDParam(DD_PARAM_CMD_MODON, DD_PARAM_STR_MODON, asynParamInt32, ¶m_modon_);
createDDParam(DD_PARAM_CMD_KP, DD_PARAM_STR_KP, asynParamFloat64, ¶m_kp_);
createDDParam(DD_PARAM_CMD_KI, DD_PARAM_STR_KI, asynParamFloat64, ¶m_ki_);
createDDParam(DD_PARAM_CMD_KD, DD_PARAM_STR_KD, asynParamFloat64, ¶m_kd_);
createDDParam(DD_PARAM_CMD_NOTCHON, DD_PARAM_STR_NOTCHON, asynParamInt32, ¶m_notchon_);
createDDParam(DD_PARAM_CMD_NOTCHF, DD_PARAM_STR_NOTCHF, asynParamInt32, ¶m_notchf_);
createDDParam(DD_PARAM_CMD_NOTCHB, DD_PARAM_STR_NOTCHB, asynParamInt32, ¶m_notchb_);
createDDParam(DD_PARAM_CMD_LPON, DD_PARAM_STR_LPON, asynParamInt32, ¶m_lpon_);
createDDParam(DD_PARAM_CMD_LPF, DD_PARAM_STR_LPF, asynParamInt32, ¶m_lpf_);
createDDParam(DD_PARAM_CMD_GASIN, DD_PARAM_STR_GASIN, asynParamFloat64, ¶m_gasin_);
createDDParam(DD_PARAM_CMD_GOSIN, DD_PARAM_STR_GOSIN, asynParamFloat64, ¶m_gosin_);
createDDParam(DD_PARAM_CMD_GFSIN, DD_PARAM_STR_GFSIN, asynParamFloat64, ¶m_gfsin_);
createDDParam(DD_PARAM_CMD_GATRI, DD_PARAM_STR_GATRI, asynParamFloat64, ¶m_gatri_);
createDDParam(DD_PARAM_CMD_GOTRI, DD_PARAM_STR_GOTRI, asynParamFloat64, ¶m_gotri_);
createDDParam(DD_PARAM_CMD_GFTRI, DD_PARAM_STR_GFTRI, asynParamFloat64, ¶m_gftri_);
createDDParam(DD_PARAM_CMD_GSTRI, DD_PARAM_STR_GSTRI, asynParamFloat64, ¶m_gstri_);
createDDParam(DD_PARAM_CMD_GAREC, DD_PARAM_STR_GAREC, asynParamFloat64, ¶m_garec_);
createDDParam(DD_PARAM_CMD_GOREC, DD_PARAM_STR_GOREC, asynParamFloat64, ¶m_gorec_);
createDDParam(DD_PARAM_CMD_GFREC, DD_PARAM_STR_GFREC, asynParamFloat64, ¶m_gfrec_);
createDDParam(DD_PARAM_CMD_GSREC, DD_PARAM_STR_GSREC, asynParamFloat64, ¶m_gsrec_);
createDDParam(DD_PARAM_CMD_GANOI, DD_PARAM_STR_GANOI, asynParamFloat64, ¶m_ganoi_);
createDDParam(DD_PARAM_CMD_GONOI, DD_PARAM_STR_GONOI, asynParamFloat64, ¶m_gonoi_);
createDDParam(DD_PARAM_CMD_GASWE, DD_PARAM_STR_GASWE, asynParamFloat64, ¶m_gaswe_);
createDDParam(DD_PARAM_CMD_GOSWE, DD_PARAM_STR_GOSWE, asynParamFloat64, ¶m_goswe_);
createDDParam(DD_PARAM_CMD_GTSWE, DD_PARAM_STR_GTSWE, asynParamFloat64, ¶m_gtswe_);
createDDParam(DD_PARAM_CMD_TRGSS, DD_PARAM_STR_TRGSS, asynParamFloat64, ¶m_trgss_);
createDDParam(DD_PARAM_CMD_TRGSE, DD_PARAM_STR_TRGSE, asynParamFloat64, ¶m_trgse_);
createDDParam(DD_PARAM_CMD_TRGSI, DD_PARAM_STR_TRGSI, asynParamFloat64, ¶m_trgsi_);
createDDParam(DD_PARAM_CMD_TRGLEN, DD_PARAM_STR_TRGLEN, asynParamInt32, ¶m_trglen_);
// MBBIO parameters
createDDParam(DD_PARAM_CMD_MONSRC, DD_PARAM_STR_MONSRC, asynParamUInt32Digital, ¶m_monsrc_);
createDDParam(DD_PARAM_CMD_GFKT, DD_PARAM_STR_GFKT, asynParamUInt32Digital, ¶m_gfkt_);
createDDParam(DD_PARAM_CMD_SCT, DD_PARAM_STR_SCT, asynParamUInt32Digital, ¶m_sct_); // sometimes has issues reading back?
createDDParam(DD_PARAM_CMD_TRGEDGE, DD_PARAM_STR_TRGEDGE, asynParamUInt32Digital, ¶m_trgedge_);
// Global parameters
createDDParam(DD_PARAM_CMD_BRIGHT, DD_PARAM_STR_BRIGHT, asynParamInt32, ¶m_bright_, true, true);
// Write-only
createDDParam(DD_PARAM_CMD_SSTD, DD_PARAM_STR_SSTD, asynParamInt32, ¶m_sstd_, false, false); // set default values
createDDParam(DD_PARAM_CMD_CL, DD_PARAM_STR_CL, asynParamInt32, ¶m_cl_, false, false); // open/closed loop
createDDParam(DD_PARAM_CMD_FBREAK, DD_PARAM_STR_FBREAK, asynParamInt32, ¶m_fbreak_, false, false); // abort soft start
// start scan sometimes doesn't readback... let's just not query it
createDDParam(DD_PARAM_CMD_SS, DD_PARAM_STR_SS, asynParamInt32, ¶m_ss_, false, false);
// Special handling:
createDDParam(DD_PARAM_CMD_WRMB, DD_PARAM_STR_ENC_RATE, asynParamInt32, ¶m_enc_rate_, false, false, true, DD_PARAM_SVC_ENC_RATE);
// Last of queryable-DDrive parameters
// Read-only (updated when status changes)
createParam(DD_PARAM_STR_PLUGGED, asynParamInt32, ¶m_plugged_);
createParam(DD_PARAM_STR_CLOSED_SYS, asynParamInt32, ¶m_closed_sys_);
createParam(DD_PARAM_STR_VOLTAGE_ON, asynParamInt32, ¶m_voltage_on_);
createParam(DD_PARAM_STR_MEAS_SYS, asynParamUInt32Digital, ¶m_meas_sys_);
// Read-write
createParam(DD_PARAM_STR_MOVE_TIMEOUT, asynParamFloat64, ¶m_move_timeout_);
if (!addToList(portName, this)) {
printf("%s:%s: Init failed", driverName, portName);
return;
}
setIntegerParam(motorStatusHasEncoder_, 1);
/* Connect to ddrive controller */
status = pasynOctetSyncIO->connect(ddrivePortName, 0, &pasynUser_, NULL);
if (status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: cannot connect to ddrive controller\n",
driverName, __func__);
}
status = pasynOctetSyncIO->setInputEos(pasynUser_, "\r", 1);
if (status) {
asynPrint(pasynUser_, ASYN_TRACE_ERROR|ASYN_TRACE_FLOW,
"%s: Unable to set input EOS on %s: %s\n",
__func__, ddrivePortName, pasynUser_->errorMessage);
}
status = pasynOctetSyncIO->setOutputEos(pasynUser_, "\r", 1);
if (status) {
asynPrint(pasynUser_, ASYN_TRACE_ERROR|ASYN_TRACE_FLOW,
"%s: Unable to set output EOS on %s: %s\n",
__func__, ddrivePortName, pasynUser_->errorMessage);
}
// Create the axis objects
for (axis=0; axis<numAxes; axis++) {
//pAxis =
new ddriveAxis(this, axis);
}
startPoller(movingPollPeriod/1000., idlePollPeriod/1000., 2);
}
/** Creates a new HXPController object.
* \param[in] portName The name of the asyn port that will be created for this driver
* \param[in] IPAddress The Newport hexapod controller's ip address
* \param[in] IPPort TCP/IP port used to communicate with the hexapod controller
* \param[in] movingPollPeriod The time between polls when any axis is moving
* \param[in] idlePollPeriod The time between polls when no axis is moving
*/
HXPController::HXPController(const char *portName, const char *IPAddress, int IPPort,
double movingPollPeriod, double idlePollPeriod)
: asynMotorController(portName, NUM_AXES, NUM_HXP_PARAMS,
0, // No additional interfaces beyond those in base class
0, // No additional callback interfaces beyond those in base class
ASYN_CANBLOCK | ASYN_MULTIDEVICE,
1, // autoconnect
0, 0) // Default priority and stack size
{
int axis;
HXPAxis *pAxis;
static const char *functionName = "HXPController::HXPController";
axisNames_ = epicsStrDup("XYZUVW");
IPAddress_ = epicsStrDup(IPAddress);
IPPort_ = IPPort;
createParam(HXPMoveCoordSysString, asynParamInt32, &HXPMoveCoordSys_);
createParam(HXPStatusString, asynParamInt32, &HXPStatus_);
createParam(HXPErrorString, asynParamInt32, &HXPError_);
createParam(HXPErrorDescString, asynParamOctet, &HXPErrorDesc_);
createParam(HXPMoveAllString, asynParamInt32, &HXPMoveAll_);
createParam(HXPMoveAllTargetXString, asynParamFloat64, &HXPMoveAllTargetX_);
createParam(HXPMoveAllTargetYString, asynParamFloat64, &HXPMoveAllTargetY_);
createParam(HXPMoveAllTargetZString, asynParamFloat64, &HXPMoveAllTargetZ_);
createParam(HXPMoveAllTargetUString, asynParamFloat64, &HXPMoveAllTargetU_);
createParam(HXPMoveAllTargetVString, asynParamFloat64, &HXPMoveAllTargetV_);
createParam(HXPMoveAllTargetWString, asynParamFloat64, &HXPMoveAllTargetW_);
createParam(HXPCoordSysReadAllString, asynParamInt32, &HXPCoordSysReadAll_);
createParam(HXPCoordSysToolXString, asynParamFloat64, &HXPCoordSysToolX_);
createParam(HXPCoordSysToolYString, asynParamFloat64, &HXPCoordSysToolY_);
createParam(HXPCoordSysToolZString, asynParamFloat64, &HXPCoordSysToolZ_);
createParam(HXPCoordSysToolUString, asynParamFloat64, &HXPCoordSysToolU_);
createParam(HXPCoordSysToolVString, asynParamFloat64, &HXPCoordSysToolV_);
createParam(HXPCoordSysToolWString, asynParamFloat64, &HXPCoordSysToolW_);
createParam(HXPCoordSysWorkXString, asynParamFloat64, &HXPCoordSysWorkX_);
createParam(HXPCoordSysWorkYString, asynParamFloat64, &HXPCoordSysWorkY_);
createParam(HXPCoordSysWorkZString, asynParamFloat64, &HXPCoordSysWorkZ_);
createParam(HXPCoordSysWorkUString, asynParamFloat64, &HXPCoordSysWorkU_);
createParam(HXPCoordSysWorkVString, asynParamFloat64, &HXPCoordSysWorkV_);
createParam(HXPCoordSysWorkWString, asynParamFloat64, &HXPCoordSysWorkW_);
createParam(HXPCoordSysBaseXString, asynParamFloat64, &HXPCoordSysBaseX_);
createParam(HXPCoordSysBaseYString, asynParamFloat64, &HXPCoordSysBaseY_);
createParam(HXPCoordSysBaseZString, asynParamFloat64, &HXPCoordSysBaseZ_);
createParam(HXPCoordSysBaseUString, asynParamFloat64, &HXPCoordSysBaseU_);
createParam(HXPCoordSysBaseVString, asynParamFloat64, &HXPCoordSysBaseV_);
createParam(HXPCoordSysBaseWString, asynParamFloat64, &HXPCoordSysBaseW_);
createParam(HXPCoordSysSetString, asynParamInt32, &HXPCoordSysSet_);
createParam(HXPCoordSysToSetString, asynParamInt32, &HXPCoordSysToSet_);
createParam(HXPCoordSysSetXString, asynParamFloat64, &HXPCoordSysSetX_);
createParam(HXPCoordSysSetYString, asynParamFloat64, &HXPCoordSysSetY_);
createParam(HXPCoordSysSetZString, asynParamFloat64, &HXPCoordSysSetZ_);
createParam(HXPCoordSysSetUString, asynParamFloat64, &HXPCoordSysSetU_);
createParam(HXPCoordSysSetVString, asynParamFloat64, &HXPCoordSysSetV_);
createParam(HXPCoordSysSetWString, asynParamFloat64, &HXPCoordSysSetW_);
// This socket is used for polling by the controller and all axes
pollSocket_ = HXPTCP_ConnectToServer((char *)IPAddress, IPPort, HXP_POLL_TIMEOUT);
if (pollSocket_ < 0) {
printf("%s:%s: error calling TCP_ConnectToServer for pollSocket\n",
driverName, functionName);
}
HXPFirmwareVersionGet(pollSocket_, firmwareVersion_);
for (axis=0; axis<NUM_AXES; axis++) {
pAxis = new HXPAxis(this, axis);
}
startPoller(movingPollPeriod, idlePollPeriod, 2);
}
