|
|
/*
|
|
|
* dsa30.h
|
|
|
*
|
|
|
* Copyright (c) 1997-2008 ETEL SA. All Rights Reserved.
|
|
|
*
|
|
|
* This software is the confidential and proprietary informatione of ETEL SA
|
|
|
* ("Confidential Information"). You shall not disclose such Confidential
|
|
|
* Information and shall use it only in accordance with the terms of the
|
|
|
* license agreement you entered into with ETEL.
|
|
|
*
|
|
|
* This software is provided "AS IS," without a warranty of any kind. ALL
|
|
|
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
|
|
|
* IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
|
|
|
* NON-INFRINGEMENT, ARE HEREBY EXCLUDED. ETEL AND ITS LICENSORS SHALL NOT BE
|
|
|
* LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
|
|
|
* OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL ETEL OR ITS
|
|
|
* LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
|
|
|
* INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
|
|
|
* CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
|
|
|
* OR INABILITY TO USE SOFTWARE, EVEN IF ETEL HAS BEEN ADVISED OF THE
|
|
|
* POSSIBILITY OF SUCH DAMAGES.
|
|
|
*
|
|
|
* This software is not designed or intended for use in on-line control of
|
|
|
* aircraft, air traffic, aircraft navigation or aircraft communications; or in
|
|
|
* the design, construction, operation or maintenance of any nuclear
|
|
|
* facility. Licensee represents and warrants that it will not use or
|
|
|
* redistribute the Software for such purposes.
|
|
|
*
|
|
|
*/
|
|
|
|
|
|
/**
|
|
|
* This header file contains public declarations for the high level library.\n
|
|
|
* This library allows access to ETEL hardware like drives, UltimET, etc...\n
|
|
|
* Once connected, it is possible to get and set registers, executing command
|
|
|
* and different functions on the hardware itself.\n
|
|
|
* This library is conformed to POSIX 1003.1c
|
|
|
* @file dsa30.h
|
|
|
*/
|
|
|
|
|
|
|
|
|
#ifndef _DSA30_H
|
|
|
#define _DSA30_H
|
|
|
|
|
|
|
|
|
/**********************************************************************************************************/
|
|
|
/*- LIBRARIES */
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
/*----------------------*/
|
|
|
/* common libraries */
|
|
|
#include <stdio.h>
|
|
|
#include <stddef.h>
|
|
|
#include <stdarg.h>
|
|
|
#include <time.h>
|
|
|
#include <string.h>
|
|
|
#if defined __cplusplus && !defined LINUX
|
|
|
#include <typeinfo.h>
|
|
|
#endif
|
|
|
|
|
|
#if defined __cplusplus && defined DSA_OO_API
|
|
|
#define DMD_OO_API
|
|
|
#endif
|
|
|
#include <dmd20.h>
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAAll DSA All functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAAcquisition DSA Acquisition
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSACommunicationAndConfiguration DSA Communication and configuration
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAControllerStatus DSA Controller status
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSADeviceHandling DSA Device handling functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAErrorsAndWarnings DSA Errors and warnings
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAFeedback DSA Feedback
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAGenericFunctions DSA Generic functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAInitialisationAndIndexation DSA Initialisation and indexation
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAInterpolation DSA Interpolation functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAMotorAndCommutation DSA Motor and commutation
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAObsolete DSA Obsolete functions (DSA/DSB only)
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAOptionalBoard DSA Optional board
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSARealtime DSA Realtime functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSARegulation DSA Regulation
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSASafetyAndProtection DSA Safety and protection
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSASaveAndRestore DSA Save and restore functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSASequenceHandling DSA Sequence handling
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSASetPointGenerator DSA Set point generator
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSATrace DSA Trace
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSATriggerRTIAndIO DSA Trigger, RTI and IO
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAUtils DSA Utility functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAWaitFunctions DSA Wait functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAGate DSA Gate functions
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSARTV DSA Realtime Value access functions (AccurET family)
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSARTVSLOT DSA RTV slots internal access functions (AccurET family)
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @defgroup DSAMap DSA Mapping download and upload functions (AccurET family)
|
|
|
*/
|
|
|
/*@{*/
|
|
|
/*@}*/
|
|
|
|
|
|
/**
|
|
|
* @example sample_1.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example sample_2.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example sample_3.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example sample_4.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example sample_5.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example dsmax_1.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example dsmax_2.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example umeg.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example rtm.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example acquisition.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example dsteb.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example gp_module.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example compiler.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example rtv1.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example rtv2.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example rtv3.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example mapping1.c
|
|
|
*/
|
|
|
/**
|
|
|
* @example scaling1.c
|
|
|
*/
|
|
|
|
|
|
|
|
|
/**********************************************************************************************************/
|
|
|
/*- LITTERALS */
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
#ifdef __WIN32__ /* defined by Borland C++ Builder */
|
|
|
#ifndef WIN32
|
|
|
#define WIN32
|
|
|
#endif
|
|
|
#endif
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
#ifdef ETEL_OO_API /* defined by the user when he need the Object Oriented interface */
|
|
|
#define DSA_OO_API
|
|
|
#endif
|
|
|
#endif
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
extern "C" {
|
|
|
#endif
|
|
|
|
|
|
/*----------------------------------------------------------------------------------*/
|
|
|
/* BYTE ORDER */
|
|
|
/*----------------------------------------------------------------------------------*/
|
|
|
|
|
|
#ifndef __BYTE_ORDER
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* Windows Byte order */
|
|
|
#if defined WIN32
|
|
|
#define __LITTLE_ENDIAN 1234
|
|
|
#define __BIG_ENDIAN 4321
|
|
|
#define __BYTE_ORDER __LITTLE_ENDIAN /* define byte order for INTEL processor */
|
|
|
#endif /*WIN32*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* QNX4 Byte order */
|
|
|
#if defined WIN32 || defined QNX4
|
|
|
#define __LITTLE_ENDIAN 1234
|
|
|
#define __BIG_ENDIAN 4321
|
|
|
#define __BYTE_ORDER __LITTLE_ENDIAN /* define byte order for INTEL processor */
|
|
|
#endif /*QNX4*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* POSIX SOLARIS Byte order */
|
|
|
#if defined POSIX && defined SOLARIS
|
|
|
#define __LITTLE_ENDIAN 1234
|
|
|
#define __BIG_ENDIAN 4321
|
|
|
#ifdef _BIG_ENDIAN
|
|
|
#define __BYTE_ORDER __BIG_ENDIAN /* define byte order for SPARC processor */
|
|
|
#else
|
|
|
#define __BYTE_ORDER __LITTLE_ENDIAN /* define byte order for SPARC processor */
|
|
|
#endif
|
|
|
#endif /*SOLARIS*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* POSIX LINUX Byte order */
|
|
|
#if defined POSIX && defined LINUX
|
|
|
#include <endian.h>
|
|
|
#endif /*LINUX*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* POSIX XENOMAI Byte order */
|
|
|
#if defined POSIX && defined XENOMAI
|
|
|
#include <endian.h>
|
|
|
#endif /*XENOMAI*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* POSIX QNX6 Byte order */
|
|
|
#if defined POSIX && defined QNX6
|
|
|
#define __LITTLE_ENDIAN 1234
|
|
|
#define __BIG_ENDIAN 4321
|
|
|
#ifdef __BIGENDIAN__
|
|
|
#define __BYTE_ORDER __BIG_ENDIAN /* define byte order for SPARC processor */
|
|
|
#else
|
|
|
#define __BYTE_ORDER __LITTLE_ENDIAN /* define byte order for SPARC processor */
|
|
|
#endif
|
|
|
#endif /*QNX6*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* VXWORKS Byte order */
|
|
|
#ifdef VXWORKS
|
|
|
#define __LITTLE_ENDIAN _LITTLE_ENDIAN
|
|
|
#define __BIG_ENDIAN _BIG_ENDIAN
|
|
|
#define __BYTE_ORDER _BYTE_ORDER
|
|
|
#endif /*VXWORKS*/
|
|
|
|
|
|
#endif /*BYTE_ORDER*/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* Number of axis
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef WIN32
|
|
|
#define DSA_DRIVES 32
|
|
|
#define DSA_ETCOM_DRIVES 64
|
|
|
#endif
|
|
|
#ifdef QNX4
|
|
|
#define DSA_DRIVES 32
|
|
|
#define DSA_ETCOM_DRIVES 64
|
|
|
#endif /* QNX4 */
|
|
|
#ifdef POSIX
|
|
|
#define DSA_DRIVES 32
|
|
|
#define DSA_ETCOM_DRIVES 64
|
|
|
#endif /* POSIX */
|
|
|
#ifdef VXWORKS
|
|
|
#define DSA_DRIVES 32
|
|
|
#define DSA_ETCOM_DRIVES 64
|
|
|
#endif /* VXWORKS */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* flags
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#define DSA_FLAG_RELAX_DRV_CHECK 0x00000001 /**< allow the use of unknowed drv version */
|
|
|
#define DSA_FLAG_DISABLE_ISO_CONV 0x00000002 /**< disable all request of drv unit informations */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* error codes - c
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#define DSA_EBADSEQVERSION -338 /**< the sequence version is not correct */
|
|
|
#define DSA_EACQDEVINUSE -337 /**< One of the device is already doing an acquisition */
|
|
|
#define DSA_EACQNOTPOSSIBLE -336 /**< Drives must be connected with transnet */
|
|
|
#define DSA_EMAPNOTACTIVATED -335 /**< Mapping cannot be activated by the device */
|
|
|
#define DSA_ESYNTAX -334 /**< Mapping file syntax error */
|
|
|
#define DSA_EBADLIBRARY -333 /**< function of external library not found */
|
|
|
#define DSA_ENOLIBRARY -332 /**< external library not found */
|
|
|
#define DSA_ERTVREADSYNCRO -331 /**< RTV read synchronisation error */
|
|
|
#define DSA_ENOFREESLOT -330 /**< no free slot available */
|
|
|
#define DSA_EOBSOLETE -329 /**< function is obsolete */
|
|
|
#define DSA_EBADDRIVER -328 /**< wrong version of the installed device driver */
|
|
|
#define DSA_EBADIPOLGRP -327 /**< the ipol group is not correctly defined */
|
|
|
#define DSA_ENOTIMPLEMENTED -326 /**< the specified operation is not implemented */
|
|
|
#define DSA_EBADDRVVER -325 /**< a drive with a bad version has been detected */
|
|
|
#define DSA_EBADSTATE -324 /**< this operation is not allowed in this state */
|
|
|
#define DSA_EDRVFAILED -323 /**< the drive does not operate properly */
|
|
|
#define DSA_EBADPARAM -322 /**< one of the parameter is not valid */
|
|
|
#define DSA_EOPENPORT -321 /**< the specified port cannot be open */
|
|
|
#define DSA_ENODRIVE -320 /**< the specified drive does not respond */
|
|
|
#define DSA_ECANCEL -319 /**< the transaction has been canceled */
|
|
|
#define DSA_ETRANS -318 /**< a transaction error has occured */
|
|
|
#define DSA_ECONVERT -317 /**< a parameter exceeded the permitted range */
|
|
|
#define DSA_EINTERNAL -316 /**< some internal error in the etel software */
|
|
|
#define DSA_ESYSTEM -315 /**< some system resource return an error */
|
|
|
#define DSA_EBUSRESET -314 /**< the underlaying etel-bus in performing a reset operation */
|
|
|
#define DSA_EBUSERROR -313 /**< the underlaying etel-bus is not working fine */
|
|
|
#define DSA_ENOACK -312 /**< no acknowledge from the drive */
|
|
|
#define DSA_EDRVERROR -311 /**< drive in error */
|
|
|
#define DSA_ETIMEOUT -310 /**< a timeout has occured */
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* convert special value / macro
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_CONV_AUTO (-1) /**< try to use the conversion appropriate for this operation */
|
|
|
#endif
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* timeout special values
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef INFINITE
|
|
|
#define INFINITE 0xFFFFFFFF /**< infinite timeout */
|
|
|
#endif
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_DEF_TIMEOUT (-2L) /**< use the default timeout appropriate for this communication */
|
|
|
#endif
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* register kind of access
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_GET_CURRENT 0 /**< get current value, bypass pending commands */
|
|
|
#define DSA_GET_WAITING 1 /**< get current value, waiting pending commands */
|
|
|
#define DSA_GET_TRACE_CURRENT 2 /**< get trace array, bypass pending commands */
|
|
|
#define DSA_GET_TRACE_WAITING 3 /**< get trace array, waiting pending commands */
|
|
|
#define DSA_GET_CONV_FACTOR 10 /**< get the conversion factor */
|
|
|
#define DSA_GET_MIN_VALUE 11 /**< get the minimum value */
|
|
|
#define DSA_GET_MAX_VALUE 12 /**< get the maximum value */
|
|
|
#define DSA_GET_DEF_VALUE 13 /**< get the default value */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* status warning bits
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_SW1_W_I2T_OVER_CURRENT 0x01 /**< the i2t integral is > 50% k85 limit */
|
|
|
#define DSA_SW1_W_OVER_TEMPERATURE 0x02 /**< the driver's temperature is > 50<35>C */
|
|
|
#define DSA_SW1_W_ENCODER_AMPLITUDE 0x10 /**< the encoder signals amplitude is < 10% */
|
|
|
#define DSA_SW1_W_TRACKING_ERROR 0x20 /**< position error is > 50% k30 limit */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* status error bits
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_SW1_E_CURRENT 0x01 /**< current error */
|
|
|
#define DSA_SW1_E_CONTROLLER 0x02 /**< controller error */
|
|
|
#define DSA_SW1_E_ETEL_BUS 0x04 /**< etel-bus error */
|
|
|
#define DSA_SW1_E_TRAJECTORY 0x08 /**< trajectory error */
|
|
|
#define DSA_SW1_E_ETEL_BUS_LITE 0x10 /**< etel-bus-lite error */
|
|
|
#define DSA_SW1_E_OTHER_AXIS 0x80 /**< other-axis error */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* STA-STI flags
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_STA_POS 0x01 /**< get the K210 specified depth as position for the next move*/
|
|
|
#define DSA_STA_SPD 0x02 /**< get the K211 specified depth as speed for the next move*/
|
|
|
#define DSA_STA_ACC 0x04 /**< get the K212 specified depth as acceleration for the next move*/
|
|
|
#define DSA_STA_JRK 0x08 /**< get the K213 specified depth as jerk for the next move*/
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* parameters enumeration values - c
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_CTRL_ENABLE_AUTO 170 /**< enable signal perform automatic power on of the drive */
|
|
|
#define DSA_CTRL_ENABLE_NOT_USED 125 /**< enable signal not used */
|
|
|
#define DSA_CTRL_ENABLE_USED 0 /**< enable signal is necessary to power on ths drive */
|
|
|
#define DSA_CTRL_FORCE_REFERENCE 0 /**< driver controlled by a force reference */
|
|
|
#define DSA_CTRL_HOME_INVERTED 2 /**< home switch is inverted */
|
|
|
#define DSA_CTRL_HOME_SWITCH 128 /**< home switch is used */
|
|
|
#define DSA_CTRL_LIMIT_SWITCH 1 /**< limit switch are used */
|
|
|
#define DSA_CTRL_POSITION_PROFILE 1 /**< standard position profile mode */
|
|
|
#define DSA_CTRL_POSITION_REFERENCE 4 /**< driver controlled by a position reference */
|
|
|
#define DSA_CTRL_PULSE_DIRECTION 5 /**< pulse and direction mode */
|
|
|
#define DSA_CTRL_PULSE_DIRECTION_TTL 6 /**< pulse and direction mode with TTL encoder */
|
|
|
#define DSA_CTRL_REGEN_LIMITED 2 /**< regeneration of, max 10s */
|
|
|
#define DSA_CTRL_REGEN_OFF 0 /**< no regeneration */
|
|
|
#define DSA_CTRL_REGEN_ON 3 /**< regeneration always on */
|
|
|
#define DSA_CTRL_SOURCE_MONITORING 3 /**< monitoring of a monitoring register */
|
|
|
#define DSA_CTRL_SOURCE_PARAMETER 2 /**< monitoring of a parameter */
|
|
|
#define DSA_CTRL_SOURCE_USER_VARIABLE 1 /**< monitoring of a user variable */
|
|
|
#define DSA_CTRL_SPEED_REFERENCE 3 /**< driver controlled by a speed reference */
|
|
|
#define DSA_DRIVE_DISPLAY_ENCODER_SIGNAL 4 /**< display encoder's signals */
|
|
|
#define DSA_DRIVE_DISPLAY_NORMAL 1 /**< display normal informations */
|
|
|
#define DSA_DRIVE_DISPLAY_SEQUENCE 8 /**< display sequence line number */
|
|
|
#define DSA_DRIVE_DISPLAY_TEMPERATURE 2 /**< display drive's temperature */
|
|
|
#define DSA_HOMING_GATED_INDEX_NEG 17 /* */
|
|
|
#define DSA_HOMING_GATED_INDEX_NEG_L 19 /* */
|
|
|
#define DSA_HOMING_GATED_INDEX_POS 16 /* */
|
|
|
#define DSA_HOMING_GATED_INDEX_POS_L 18 /* */
|
|
|
#define DSA_HOMING_HOME_SW_NEG 3 /* */
|
|
|
#define DSA_HOMING_HOME_SW_NEG_L 7 /* */
|
|
|
#define DSA_HOMING_HOME_SW_POS 2 /* */
|
|
|
#define DSA_HOMING_HOME_SW_POS_L 6 /* */
|
|
|
#define DSA_HOMING_LIMIT_SW_NEG 5 /* */
|
|
|
#define DSA_HOMING_LIMIT_SW_POS 4 /* */
|
|
|
#define DSA_HOMING_MECHANICAL_NEG 1 /* */
|
|
|
#define DSA_HOMING_MECHANICAL_POS 0 /* */
|
|
|
#define DSA_HOMING_MULTI_INDEX_NEG 13 /* */
|
|
|
#define DSA_HOMING_MULTI_INDEX_NEG_L 15 /* */
|
|
|
#define DSA_HOMING_MULTI_INDEX_POS 12 /* */
|
|
|
#define DSA_HOMING_MULTI_INDEX_POS_L 14 /* */
|
|
|
#define DSA_HOMING_SINGLE_INDEX_NEG 9 /* */
|
|
|
#define DSA_HOMING_SINGLE_INDEX_NEG_L 11 /* */
|
|
|
#define DSA_HOMING_SINGLE_INDEX_POS 8 /* */
|
|
|
#define DSA_HOMING_SINGLE_INDEX_POS_L 10 /* */
|
|
|
#define DSA_INIT_CONTINUOUS_CURRENT 2 /**< initialisation by sending continous to the motor */
|
|
|
#define DSA_INIT_CURRENT_PULSE 1 /**< initialisation with current pulses */
|
|
|
#define DSA_INIT_NO_INIT 0 /**< no initialisation */
|
|
|
#define DSA_MON_SOURCE_MONITORING 3 /**< monitoring of a monitoring register */
|
|
|
#define DSA_MON_SOURCE_OFF 0 /**< no real time monitoring */
|
|
|
#define DSA_MON_SOURCE_PARAMETER 2 /**< monitoring of a parameter */
|
|
|
#define DSA_MON_SOURCE_USER_VARIABLE 1 /**< monitoring of a user variable */
|
|
|
#define DSA_MOTOR_INVERT_FORCE 2 /**< invert current force of the motor */
|
|
|
#define DSA_MOTOR_INVERT_PHASES 1 /**< invert phases 1 and 2 of the motor */
|
|
|
#define DSA_PARAM_DEFAULT_ALL 0 /**< restore all informations from ROM default */
|
|
|
#define DSA_PARAM_DEFAULT_SEQ_LKT 1 /**< restore sequence and user lookup-tables from ROM default */
|
|
|
#define DSA_PARAM_DEFAULT_K_C_PARAMS 2 /**< restore K, and KL, KF, KD, C, CL, CF CD if any, parameters from ROM default */
|
|
|
#define DSA_PARAM_DEFAULT_K_RESET_E_PARAMS 3 /**< restore K, KL, KF, KD parameters from ROM default, reset EL parameters*/
|
|
|
#define DSA_PARAM_DEFAULT_C_PARAMS 4 /**< restore C, CL, CF, CD parameters from ROM default */
|
|
|
#define DSA_PARAM_DEFAULT_X_PARAMS 5 /**< reset X, XL, XF, XD parameters */
|
|
|
#define DSA_PARAM_DEFAULT_L_PARAMS 6 /**< reset LD parameters */
|
|
|
#define DSA_PARAM_DEFAULT_SEQUENCES 7 /**< reset sequences */
|
|
|
#define DSA_PARAM_DEFAULT_E_PARAMS 8 /**< reset E parameters */
|
|
|
#define DSA_PARAM_DEFAULT_P_PARAMS 9 /**< reset P parameters */
|
|
|
#define DSA_PARAM_LOAD_ALL 0 /**< load all informations from flash memory */
|
|
|
#define DSA_PARAM_LOAD_SEQ_LKT 1 /**< load sequence and user lookup-tables from flash memory */
|
|
|
#define DSA_PARAM_LOAD_K_C_E_X_PARAMS 2 /**< load K, KL, KF, KD, C, CL, CF, CD, EL, X, XL, XF, XD parameters from flash memory */
|
|
|
#define DSA_PARAM_LOAD_K_PARAMS 3 /**< load K, KL, KF, KD parameters from flash memory */
|
|
|
#define DSA_PARAM_LOAD_C_PARAMS 4 /**< load C, CL, CF, CD parameters from flash memory */
|
|
|
#define DSA_PARAM_LOAD_X_PARAMS 5 /**< load X, XL, XF, XD parameters from flash memory */
|
|
|
#define DSA_PARAM_LOAD_L_PARAMS 6 /**< load LD parameters from flash memory */
|
|
|
#define DSA_PARAM_LOAD_SEQUENCES 7 /**< load sequences from flash memory */
|
|
|
#define DSA_PARAM_LOAD_E_PARAMS 8 /**< load EL parameters from flash memory */
|
|
|
#define DSA_PARAM_LOAD_P_PARAMS 9 /**< load P parameters from flash memory */
|
|
|
#define DSA_PARAM_SAVE_ALL 0 /**< save all informations in flash memory */
|
|
|
#define DSA_PARAM_SAVE_SEQ_LKT 1 /**< save sequence and user lookup-tables in flash memory */
|
|
|
#define DSA_PARAM_SAVE_K_C_E_X_PARAMS 2 /**< save K, KL, KF, KD, C, CL, CF, CD, EL, X, XL, XF, XD parameters in flash memory */
|
|
|
#define DSA_PARAM_SAVE_K_PARAMS 3 /**< save K, KL, KF, KD parameters in flash memory */
|
|
|
#define DSA_PARAM_SAVE_C_PARAMS 4 /**< save C, CL, CF, CD parameters in flash memory */
|
|
|
#define DSA_PARAM_SAVE_X_PARAMS 5 /**< save X, XL, XF, XD parameters in flash memory */
|
|
|
#define DSA_PARAM_SAVE_L_PARAMS 6 /**< save LD parameters in flash memory */
|
|
|
#define DSA_PARAM_SAVE_SEQUENCES 7 /**< save sequences in flash memory */
|
|
|
#define DSA_PARAM_SAVE_K_E_PARAMS 8 /**< save K, KL, KF, KD, EL parameters in flash memory */
|
|
|
#define DSA_PARAM_SAVE_P_PARAMS 9 /**< save P parameters in flash memory */
|
|
|
#define DSA_PL_INTEGRATOR_IN_POSITION 1 /**< integrator off during motion */
|
|
|
#define DSA_PL_INTEGRATOR_OFF 2 /**< integrator always off */
|
|
|
#define DSA_PL_INTEGRATOR_ON 0 /**< integrator always on */
|
|
|
#define DSA_PROFILE_TRAPEZIODAL_MVT 0 /**< trapezoidal motion (jerk = infinite) (obsolete DSB) */
|
|
|
#define DSA_PROFILE_S_CURVE_MVT 1 /**< s-curve motion */
|
|
|
#define DSA_PROFILE_RECTANGULAR_MVT 2 /**< trapezoidal motion (jerk = 0, acc = infinite) (obsolete DSB) */
|
|
|
#define DSA_PROFILE_PREDEFINED_PROFILE_MVT 3 /**< predefined profile motion (DSC family only) */
|
|
|
#define DSA_PROFILE_SLOW_LKT_MVT 10 /**< lookup-table motion in profile interrupt (DSC family only)*/
|
|
|
#define DSA_PROFILE_FAST_LKT_MVT 11 /**< lookup-table motion in controller interrupt (DSC family only)*/
|
|
|
#define DSA_PROFILE_ROTARY_S_CURVE_MVT 17 /**< rotary s-curve motion */
|
|
|
#define DSA_PROFILE_ROTARY_PREDEFINED_PROFILE_MVT 19 /**< rotary predefined profile motion (DSC family only) */
|
|
|
#define DSA_PROFILE_INFINITE_ROTARY_MVT 24 /**< infinite rotary motion */
|
|
|
#define DSA_PROFILE_ROTARY_LKT_MVT 26 /**< rotary lookup-table motion (DSC family only)*/
|
|
|
#define DSA_QS_BYPASS 2 /**< bypass all pending command */
|
|
|
#define DSA_QS_INFINITE_DEC 1 /**< stop motor with infinite deceleration (step) */
|
|
|
#define DSA_QS_POWER_OFF 0 /**< switch off power bridge */
|
|
|
#define DSA_QS_PROGRAMMED_DEC 2 /**< stop motor with programmed deceleration */
|
|
|
#define DSA_QS_STOP_SEQUENCE 1 /**< also stop the sequence */
|
|
|
#define DSA_ROTATION_PLAN_XT 2 /**< rotation of the XTheta plan */
|
|
|
#define DSA_ROTATION_PLAN_XY 0 /**< rotation of the XY plan */
|
|
|
#define DSA_ROTATION_PLAN_XZ 1 /**< rotation of the XZ plan */
|
|
|
#define DSA_ROTATION_PLAN_YT 4 /**< rotation of the YT plan */
|
|
|
#define DSA_ROTATION_PLAN_YZ 3 /**< rotation of the YZ plan */
|
|
|
#define DSA_ROTATION_PLAN_ZT 5 /**< rotation of the ZT plan */
|
|
|
#define DSA_SYSTEM_ANALOG 0 /**< analog sine/cosine encoder */
|
|
|
#define DSA_SYSTEM_HALL 2 /**< HALL effect encoder */
|
|
|
#define DSA_SYSTEM_TTL 1 /**< TTL encoder */
|
|
|
#define DSA_USER_CHANNEL_12 12 /**< user channel 12 */
|
|
|
#define DSA_USER_CHANNEL_13 13 /**< user channel 13 */
|
|
|
#define DSA_USER_CHANNEL_14 14 /**< user channel 14 */
|
|
|
#define DSA_USER_CHANNEL_15 15 /**< user channel 15 */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* acquisition constants - c
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_ACQUISITION_TRIG_IMMEDIATE 0 /**< trig immediately */
|
|
|
#define DSA_ACQUISITION_TRIG_START_MOVE 1 /**< trig on move start */
|
|
|
#define DSA_ACQUISITION_TRIG_END_MOVE 2 /**< trig on move end */
|
|
|
#define DSA_ACQUISITION_TRIG_POSITION 3 /**< trig on position level crossed */
|
|
|
#define DSA_ACQUISITION_TRIG_TRACE 4 /**< trig on trace level crossed */
|
|
|
#define DSA_ACQUISITION_TRIG_EXTERNAL 5 /**< external trig */
|
|
|
#define DSA_ACQUISITION_TRIG_REGISTER 6 /**< trig on given value of register */
|
|
|
#define DSA_ACQUISITION_TRIG_BIT_FIELD_STATE 7 /**< trig on bit field state */
|
|
|
#define DSA_ACQUISITION_TRIG_BIT_FIELD_EDGE 8 /**< trig on bit field riging or falling edge */
|
|
|
|
|
|
#define DSA_ACQUISITION_SYNCHRO_MODE_NONE 0 /**< each device will have its own time rate, given time and number of point will be respected */
|
|
|
#define DSA_ACQUISITION_SYNCHRO_MODE_COMMON_STI 1 /**< a common time rate is choosen for all device, only given number of point will be respected */
|
|
|
#define DSA_ACQUISITION_SYNCHRO_MODE_MIN_STI 2 /**< the time rate of the fastest device is choosen as reference, only given number of point will be respected */
|
|
|
|
|
|
#define DSA_ACQUISITION_UPLOAD_MODE_AVOID_FAST 1 /**< no traces will be uploaded as fast */
|
|
|
|
|
|
#define DSA_ACQUISITION_FALLING_EDGE -1 /**< trig on falling edge */
|
|
|
#define DSA_ACQUISITION_BOTH_EDGE 0 /**< trig on falling and rising edge */
|
|
|
#define DSA_ACQUISITION_RISING_EDGE 1 /**< trig on rising edge */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* gate definitions
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_GATE_COMET_ID 0 /**< id of ComET Application */
|
|
|
#define DSA_GATE_USER_ID_1 1 /**< id of User Application 1 */
|
|
|
#define DSA_GATE_USER_ID_2 2 /**< id of User Application 2 */
|
|
|
#define DSA_GATE_USER_ID_3 3 /**< id of User Application 3 */
|
|
|
#define DSA_GATE_USER_MAX 3 /**< max application */
|
|
|
|
|
|
#define DSA_GATE_TYPE_NORMAL 0 /**< Normal gate */
|
|
|
#define DSA_GATE_TYPE_SEQUENTIAL 1 /**< ^Sequential gate */
|
|
|
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* scaling mode definitions
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_SCALE_MAPPING_MODE_ZERO_EDGE 1 /**< 0 will be add at each ends of the scaling area */
|
|
|
#define DSA_SCALE_MAPPING_MODE_SPLINE 2 /**< the points defined in scaling area will be splined */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* scaling activation definitions
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef DSA_OO_API
|
|
|
#define DSA_SCALE_MAPPING_LINEAR_ACTIVATION 0 /**< Activation of linear scale-mapping */
|
|
|
#define DSA_SCALE_MAPPING_CYCLIC_ACTIVATION 1 /**< Activation of cyclic scale-mapping */
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
/**********************************************************************************************************/
|
|
|
/*- MACROS */
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
#ifdef WIN32
|
|
|
#ifndef DSA_VB
|
|
|
#define DSA_IMPL_A
|
|
|
#endif /* DSA_VB */
|
|
|
#define DSA_IMPL_S
|
|
|
#define DSA_IMPL_G
|
|
|
#endif /* WIN32 */
|
|
|
|
|
|
#ifdef QNX4
|
|
|
#define DSA_IMPL_A
|
|
|
#define DSA_IMPL_S
|
|
|
#define DSA_IMPL_G
|
|
|
#endif /* QNX4 */
|
|
|
|
|
|
#ifdef POSIX
|
|
|
#define DSA_IMPL_A
|
|
|
#define DSA_IMPL_S
|
|
|
#define DSA_IMPL_G
|
|
|
#endif /* POSIX */
|
|
|
|
|
|
#ifdef VXWORKS
|
|
|
#define DSA_IMPL_A
|
|
|
#define DSA_IMPL_S
|
|
|
#define DSA_IMPL_G
|
|
|
#endif /* VXWORKS */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* conversion macros
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#define DSA_REG_CONV(typ, idx, sidx) (0x10000000 + ((typ)<<20) + ((sidx)<<16) + (idx))
|
|
|
#define DSA_PPK_CONV(idx, sidx) (0x10200000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_KL_CONV(idx, sidx) (0x14200000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_KF_CONV(idx, sidx) (0x12200000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_KD_CONV(idx, sidx) (0x16200000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_MON_CONV(idx, sidx) (0x10300000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_ML_CONV(idx, sidx) (0x14300000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_MF_CONV(idx, sidx) (0x12300000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_MD_CONV(idx, sidx) (0x16300000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_C_CONV(idx, sidx) (0x10D00000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_CL_CONV(idx, sidx) (0x14D00000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_CF_CONV(idx, sidx) (0x12D00000 + ((sidx)<<16) + (idx))
|
|
|
#define DSA_CD_CONV(idx, sidx) (0x16D00000 + ((sidx)<<16) + (idx))
|
|
|
|
|
|
#define DSA_CMD_CONV(typ, idx, par) (0x20000000 + ((typ)<<20) + ((par)<<16) + (idx))
|
|
|
|
|
|
#define DSA_GET_CONV_KIND(code) (((unsigned)(code)) >> 28)
|
|
|
#define DSA_GET_CONV_TYP(code) (((code) >> 20) & 0xFFU)
|
|
|
#define DSA_GET_CONV_IDX(code) ((code) & 0xFFFFUL)
|
|
|
#define DSA_GET_CONV_PAR(code) (((code) >> 16) & 0xFFU)
|
|
|
#define DSA_GET_CONV_SIDX(code) (((code) >> 16) & 0xFU)
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* diagnostic macros
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#define DSA_DIAG(err, dev) (dsa_diag(__FILE__, __LINE__, err, dev))
|
|
|
#define DSA_SDIAG(str, err, dev) (dsa_sdiag(str, __FILE__, __LINE__, err, dev))
|
|
|
#define DSA_FDIAG(output_file_name, err, dev) (dsa_fdiag(output_file_name, __FILE__, __LINE__, err, dev))
|
|
|
|
|
|
#define DSA_EXT_DIAG(err, dev) (dsa_ext_diag(__FILE__, __LINE__, err, dev))
|
|
|
#define DSA_EXT_SDIAG(size, str, err, dev) (dsa_ext_sdiag(size, str, __FILE__, __LINE__, err, dev))
|
|
|
#define DSA_EXT_FDIAG(output_file_name, err, dev) (dsa_ext_fdiag(output_file_name, __FILE__, __LINE__, err, dev))
|
|
|
|
|
|
/**********************************************************************************************************/
|
|
|
/*- TYPES */
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* type modifiers
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/*------------------------------*/
|
|
|
/* WINDOWS type modifiers */
|
|
|
#ifdef WIN32
|
|
|
#define _DSA_EXPORT __cdecl /* function exported by static library */
|
|
|
#define DSA_CALLBACK __cdecl /* client callback function called by library */
|
|
|
#endif /* WIN32 */
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* QNX4 type modifiers */
|
|
|
#ifdef QNX4
|
|
|
#define _DSA_EXPORT __cdecl /* function exported by library */
|
|
|
#define DSA_CALLBACK __cdecl /* client callback function called by library */
|
|
|
#endif /* QNX4 */
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* POSIX type modifiers */
|
|
|
#ifdef POSIX
|
|
|
#define _DSA_EXPORT /* function exported by library */
|
|
|
#define DSA_CALLBACK /* client callback function called by library */
|
|
|
#endif /* POSIX */
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* VXWORKS type modifiers */
|
|
|
#ifdef VXWORKS
|
|
|
#define _DSA_EXPORT /* function exported by library */
|
|
|
#define DSA_CALLBACK /* client callback function called by library */
|
|
|
#endif /* VXWORKS */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* hidden structures for library clients
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifndef ETB
|
|
|
#define ETB void
|
|
|
struct EtbBus { ETB *etb; };
|
|
|
#endif
|
|
|
#ifndef DMD
|
|
|
#define DMD void
|
|
|
struct DmdData { DMD *dmd; };
|
|
|
#endif
|
|
|
#ifndef DSA_DEVICE_BASE
|
|
|
#define DSA_DEVICE_BASE void
|
|
|
#endif
|
|
|
#ifndef DSA_DEVICE
|
|
|
#define DSA_DEVICE void
|
|
|
#endif
|
|
|
#ifndef DSA_DEVICE_GROUP
|
|
|
#define DSA_DEVICE_GROUP void
|
|
|
#endif
|
|
|
#ifndef DSA_DRIVE_BASE
|
|
|
#define DSA_DRIVE_BASE void
|
|
|
#endif
|
|
|
#ifndef DSA_DRIVE
|
|
|
#define DSA_DRIVE void
|
|
|
#endif
|
|
|
#ifndef DSA_DRIVE_GROUP
|
|
|
#define DSA_DRIVE_GROUP void
|
|
|
#endif
|
|
|
#ifndef DSA_GANTRY
|
|
|
#define DSA_GANTRY void
|
|
|
#endif
|
|
|
#ifndef DSA_DSMAX_BASE
|
|
|
#define DSA_DSMAX_BASE void
|
|
|
#endif
|
|
|
#ifndef DSA_DSMAX
|
|
|
#define DSA_DSMAX void
|
|
|
#endif
|
|
|
#ifndef DSA_DSMAX_GROUP
|
|
|
#define DSA_DSMAX_GROUP void
|
|
|
#endif
|
|
|
#ifndef DSA_IPOL_GROUP
|
|
|
#define DSA_IPOL_GROUP void
|
|
|
#endif
|
|
|
#ifndef DSA_GP_MODULE_BASE
|
|
|
#define DSA_GP_MODULE_BASE void
|
|
|
#endif
|
|
|
#ifndef DSA_GP_MODULE
|
|
|
#define DSA_GP_MODULE void
|
|
|
#endif
|
|
|
#ifndef DSA_GP_MODULE_GROUP
|
|
|
#define DSA_GP_MODULE_GROUP void
|
|
|
#endif
|
|
|
#ifndef DSA_ACQUISITION
|
|
|
#define DSA_ACQUISITION void
|
|
|
#endif
|
|
|
#ifndef DSA_RTV_SLOT
|
|
|
#define DSA_RTV_SLOT void
|
|
|
#endif
|
|
|
#ifndef DSA_RTV_DATA
|
|
|
#define DSA_RTV_DATA void
|
|
|
#endif
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* extended types
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/*--------------------------*/
|
|
|
/* byte type */
|
|
|
#ifndef __BYTE
|
|
|
#define __BYTE
|
|
|
typedef unsigned char byte;
|
|
|
#endif
|
|
|
|
|
|
/*--------------------------*/
|
|
|
/* word type */
|
|
|
#ifndef __WORD
|
|
|
#define __WORD
|
|
|
typedef unsigned short word;
|
|
|
#endif
|
|
|
|
|
|
/*--------------------------*/
|
|
|
/* dword type */
|
|
|
#ifndef __DWORD
|
|
|
#define __DWORD
|
|
|
typedef unsigned int dword;
|
|
|
#endif
|
|
|
|
|
|
/*--------------------------*/
|
|
|
/* char_p type */
|
|
|
#ifndef __CHAR_P
|
|
|
#define __CHAR_P
|
|
|
typedef char *char_p;
|
|
|
#endif
|
|
|
|
|
|
/*--------------------------*/
|
|
|
/* char_cp type */
|
|
|
#ifndef __CHAR_CP
|
|
|
#define __CHAR_CP
|
|
|
typedef const char *char_cp;
|
|
|
#ifndef __cplusplus
|
|
|
#ifndef __BOOL
|
|
|
#define __BOOL
|
|
|
typedef byte bool;
|
|
|
#endif /*BOOL */
|
|
|
#endif /*__cplusplus */
|
|
|
#endif /*CHAR_CP */
|
|
|
|
|
|
/*--------------------------*/
|
|
|
/* 64 bits integer */
|
|
|
#ifndef __INT64
|
|
|
#define __INT64
|
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
|
typedef struct INT64_DWORD_MODE {
|
|
|
dword low_dword;
|
|
|
dword high_dword;
|
|
|
} INT64_DWORD_MODE;
|
|
|
#else /*__BYTE_ORDER*/
|
|
|
typedef struct INT64_DWORD_MODE {
|
|
|
dword high_dword;
|
|
|
dword low_dword;
|
|
|
} INT64_DWORD_MODE;
|
|
|
#endif /*__BYTE_ORDER*/
|
|
|
|
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
|
typedef struct INT64_BYTE_MODE {
|
|
|
byte byte0;
|
|
|
byte byte1;
|
|
|
byte byte2;
|
|
|
byte byte3;
|
|
|
byte byte4;
|
|
|
byte byte5;
|
|
|
byte byte6;
|
|
|
byte byte7;
|
|
|
} INT64_BYTE_MODE;
|
|
|
#else /*__BYTE_ORDER*/
|
|
|
typedef struct INT64_BYTE_MODE {
|
|
|
byte byte7;
|
|
|
byte byte6;
|
|
|
byte byte5;
|
|
|
byte byte4;
|
|
|
byte byte3;
|
|
|
byte byte2;
|
|
|
byte byte1;
|
|
|
byte byte0;
|
|
|
} INT64_BYTE_MODE;
|
|
|
#endif /*__BYTE_ORDER*/
|
|
|
|
|
|
/*------------------------------*/
|
|
|
/* WINDOWS 64 bits integer */
|
|
|
#if defined WIN32
|
|
|
#ifdef _MSC_VER
|
|
|
//Microsoft Compiler <= 6
|
|
|
#if _MSC_VER <= 1200
|
|
|
#define eint64 _int64
|
|
|
#else
|
|
|
#define eint64 long long
|
|
|
#endif
|
|
|
#else
|
|
|
#define eint64 long long
|
|
|
#endif
|
|
|
/*------------------------------*/
|
|
|
/* POSIX 64 bits integer */
|
|
|
#elif defined POSIX
|
|
|
#define eint64 long long
|
|
|
/*--------------------------------------*/
|
|
|
/* QNX4 and VXWORKS 64 bits integer */
|
|
|
/* On these systems,64 bits integer are not standard */
|
|
|
#elif (defined QNX4 || defined VXWORKS)
|
|
|
typedef union eint64 {
|
|
|
INT64_DWORD_MODE dwords;
|
|
|
INT64_BYTE_MODE bytes;
|
|
|
byte raw[8];
|
|
|
} eint64;
|
|
|
#endif
|
|
|
#endif
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_SW1 type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_SW1
|
|
|
* Etel bus drive status word 1 when acces through M60.\n
|
|
|
* Obsolete.\n
|
|
|
* This structure is kept to backwards compatibility only (obsolete DSA and DSB)\n
|
|
|
* EDI internal status update works now with M63. See DsaStatusDriveBitMode structure
|
|
|
*/
|
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
|
typedef struct DSA_SW1 {
|
|
|
#ifndef DSA_OO_API
|
|
|
unsigned power_on:1; /**< The power is applied to the motor */
|
|
|
unsigned init_done:1; /**< The initialisation procedure has been done */
|
|
|
unsigned homing_done:1; /**< The homing procedure has been done */
|
|
|
unsigned present:1; /**< The drive is present */
|
|
|
unsigned moving:1; /**< The motor is moving */
|
|
|
unsigned in_window:1; /**< The motor is the target windows */
|
|
|
unsigned master:1; /**< The drive is in master mode */
|
|
|
unsigned busy:1; /**< The drive is busy */
|
|
|
unsigned exec_seq:1; /**< A sequence is running */
|
|
|
unsigned edit_mode:1; /**< The sequence can be edited */
|
|
|
unsigned fatal:1; /**< Fatal error */
|
|
|
unsigned trace_busy:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned bridge:1; /**< The drive is in bridge mode */
|
|
|
unsigned homing:1; /**< The motor is homing */
|
|
|
unsigned ebl_to_eb:1; /**< The EBL is routed transparentrly to EB (download) */
|
|
|
unsigned spy:1; /**< A slave is used as a spy: master of labView channel */
|
|
|
unsigned warning:8; /**< Warning mask */
|
|
|
unsigned error:8; /**< Error mask */
|
|
|
#else /* DSA_OO_API */
|
|
|
/*
|
|
|
* status warning bits
|
|
|
*/
|
|
|
public:
|
|
|
enum { W_I2T_OVER_CURRENT = 0x01 }; /* the i2t integral is > 50% k85 limit */
|
|
|
enum { W_OVER_TEMPERATURE = 0x02 }; /* the driver's temperature is > 50<35>C */
|
|
|
enum { W_ENCODER_AMPLITUDE = 0x10 }; /* the encoder signals amplitude is < 10% */
|
|
|
enum { W_TRACKING_ERROR = 0x20 }; /* position error is > 50% k30 limit */
|
|
|
/*
|
|
|
* status error bits
|
|
|
*/
|
|
|
public:
|
|
|
enum { E_CURRENT = 0x01 }; /* current error */
|
|
|
enum { E_CONTROLLER = 0x02 }; /* controller error */
|
|
|
enum { E_ETEL_BUS = 0x04 }; /* etel-bus error */
|
|
|
enum { E_TRAJECTORY = 0x08 }; /* trajectory error */
|
|
|
enum { E_ETEL_BUS_LITE = 0x10 }; /* etel-bus-lite error */
|
|
|
enum { E_OTHER_AXIS = 0x80 }; /* other-axis error */
|
|
|
|
|
|
unsigned powerOn:1; /* the power is applied to the motor */
|
|
|
unsigned initDone:1; /* the initialisation procedure has been done */
|
|
|
unsigned homingDone:1; /* the homing procedure has been done */
|
|
|
unsigned present:1; /* the drive is present */
|
|
|
unsigned moving:1; /* the motor is moving */
|
|
|
unsigned inWindow:1; /* the motor is the target windows */
|
|
|
unsigned master:1; /* the drive is in master mode */
|
|
|
unsigned busy:1; /* the drive is busy */
|
|
|
unsigned execSeq:1; /* a sequence is running */
|
|
|
unsigned editMode:1; /* the sequence can be edited */
|
|
|
unsigned fatal:1; /* fatal error */
|
|
|
unsigned traceBusy:1; /* the aquisition of the trace is not finished */
|
|
|
unsigned bridge:1; /* the drive is in bridge mode */
|
|
|
unsigned homing:1; /* the motor is homing */
|
|
|
unsigned eblToEb:1; /* the EBL is routed transparentrly to EB (download) */
|
|
|
unsigned spy:1; /* a slave is used as a spy: master of labView channel */
|
|
|
unsigned warning:8; /* warning mask */
|
|
|
unsigned error:8; /* error mask */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DSA_SW1;
|
|
|
|
|
|
#else /*__BYTE_ORDER == __BIG_ENDIAN*/
|
|
|
typedef struct DSA_SW1 {
|
|
|
#ifndef DSA_OO_API
|
|
|
unsigned error:8; /**< Eror mask */
|
|
|
unsigned warning:8; /**< Wrning mask */
|
|
|
unsigned spy:1; /**< Aslave is used as a spy: master of labView channel */
|
|
|
unsigned ebl_to_eb:1; /**< The EBL is routed transparentrly to EB (download) */
|
|
|
unsigned homing:1; /**< The motor is homing */
|
|
|
unsigned bridge:1; /**< The drive is in bridge mode */
|
|
|
unsigned trace_busy:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned fatal:1; /**< Fatal error */
|
|
|
unsigned edit_mode:1; /**< The sequence can be edited */
|
|
|
unsigned exec_seq:1; /**< A sequence is running */
|
|
|
unsigned busy:1; /**< The drive is busy */
|
|
|
unsigned master:1; /**< The drive is in master mode */
|
|
|
unsigned in_window:1; /**< The motor is the target windows */
|
|
|
unsigned moving:1; /**< The motor is moving */
|
|
|
unsigned present:1; /**< The drive is present */
|
|
|
unsigned homing_done:1; /**< The homing procedure has been done */
|
|
|
unsigned init_done:1; /**< The initialisation procedure has been done */
|
|
|
unsigned power_on:1; /**< The power is applied to the motor */
|
|
|
#else /* DSA_OO_API */
|
|
|
/*
|
|
|
* status warning bits
|
|
|
*/
|
|
|
public:
|
|
|
enum { W_I2T_OVER_CURRENT = 0x01 }; /* the i2t integral is > 50% k85 limit */
|
|
|
enum { W_OVER_TEMPERATURE = 0x02 }; /* the driver's temperature is > 50<35>C */
|
|
|
enum { W_ENCODER_AMPLITUDE = 0x10 }; /* the encoder signals amplitude is < 10% */
|
|
|
enum { W_TRACKING_ERROR = 0x20 }; /* position error is > 50% k30 limit */
|
|
|
/*
|
|
|
* status error bits
|
|
|
*/
|
|
|
public:
|
|
|
enum { E_CURRENT = 0x01 }; /* current error */
|
|
|
enum { E_CONTROLLER = 0x02 }; /* controller error */
|
|
|
enum { E_ETEL_BUS = 0x04 }; /* etel-bus error */
|
|
|
enum { E_TRAJECTORY = 0x08 }; /* trajectory error */
|
|
|
enum { E_ETEL_BUS_LITE = 0x10 }; /* etel-bus-lite error */
|
|
|
enum { E_OTHER_AXIS = 0x80 }; /* other-axis error */
|
|
|
|
|
|
unsigned error:8; /* error mask */
|
|
|
unsigned warning:8; /* warning mask */
|
|
|
unsigned spy:1; /* a slave is used as a spy: master of labView channel */
|
|
|
unsigned eblToEb:1; /* the EBL is routed transparentrly to EB (download) */
|
|
|
unsigned homing:1; /* the motor is homing */
|
|
|
unsigned bridge:1; /* the drive is in bridge mode */
|
|
|
unsigned traceBusy:1; /* the aquisition of the trace is not finished */
|
|
|
unsigned fatal:1; /* fatal error */
|
|
|
unsigned editMode:1; /* the sequence can be edited */
|
|
|
unsigned execSeq:1; /* a sequence is running */
|
|
|
unsigned busy:1; /* the drive is busy */
|
|
|
unsigned master:1; /* the drive is in master mode */
|
|
|
unsigned inWindow:1; /* the motor is the target windows */
|
|
|
unsigned moving:1; /* the motor is moving */
|
|
|
unsigned present:1; /* the drive is present */
|
|
|
unsigned homingDone:1; /* the homing procedure has been done */
|
|
|
unsigned initDone:1; /* the initialisation procedure has been done */
|
|
|
unsigned powerOn:1; /* the power is applied to the motor */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DSA_SW1;
|
|
|
#endif /*__BYTE_ORDER*/
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_SW2 type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_SW2
|
|
|
* Etel bus drive status word 2 when acces through M61.\n
|
|
|
* Obsolete.\n
|
|
|
* This structure is kept to backwards compatibility only (obsolete DSA and DSB)\n
|
|
|
* EDI internal status update works now with M63. See DsaStatusDriveBitMode structure\n
|
|
|
*/
|
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
|
typedef struct DSA_SW2 {
|
|
|
#ifndef DSA_OO_API
|
|
|
unsigned seq_error:1; /**< Error label has been executed */
|
|
|
unsigned seq_warning:1; /**< Warning label has been executed */
|
|
|
unsigned save_pos:1; /**< Position has been reached */
|
|
|
unsigned :5;
|
|
|
unsigned user:8; /**< User status */
|
|
|
unsigned :12;
|
|
|
unsigned dll:4; /**< Used internally by dlls */
|
|
|
#else /* DSA_OO_API */
|
|
|
unsigned seqError:1; /* error label has been executed */
|
|
|
unsigned seqWarning:1; /* warning label has been executed */
|
|
|
unsigned savePos:1; /* Position has been reached */
|
|
|
unsigned :5;
|
|
|
unsigned user:8; /* user status */
|
|
|
unsigned :12;
|
|
|
unsigned dll:4; /* used internally by dlls */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DSA_SW2;
|
|
|
#else /*__BYTE_ORDER == __BIG_ENDIAN*/
|
|
|
typedef struct DSA_SW2 {
|
|
|
#ifndef DSA_OO_API
|
|
|
unsigned dll:4; /**< Used internally by dlls */
|
|
|
unsigned :12;
|
|
|
unsigned user:8; /**< User status */
|
|
|
unsigned :5;
|
|
|
unsigned save_pos:1; /**< Position has been reached */
|
|
|
unsigned seq_warning:1; /**< Warning label has been executed */
|
|
|
unsigned seq_error:1; /**< Error label has been executed */
|
|
|
#else /* DSA_OO_API */
|
|
|
unsigned dll:4; /* used internally by dlls */
|
|
|
unsigned :12;
|
|
|
unsigned user:8; /* user status */
|
|
|
unsigned :5;
|
|
|
unsigned savePos:1; /* Position has been reached */
|
|
|
unsigned seqWarning:1; /* warning label has been executed */
|
|
|
unsigned seqError:1; /* error label has been executed */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DSA_SW2;
|
|
|
#endif/*__BYTE_ORDER*/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusSWMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusSWMode
|
|
|
* Allow access to drive status with DSA_SW1(M60) and DSA_SW2(M61) members.\n
|
|
|
* Obsolete.\n
|
|
|
* This structure is kept to backwards compatibility only (obsolete DSA and DSB)\n
|
|
|
* EDI internal status update works now with M63. See DsaStatusDriveBitMode structure
|
|
|
*/
|
|
|
typedef struct DsaStatusSWMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
DSA_SW1 sw1; /**< Drive status SW1(M60) */
|
|
|
DSA_SW2 sw2; /**< Drive status SW2(M61) */
|
|
|
} DsaStatusSWMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusRawMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusRawMode
|
|
|
* Allow access to drive status with dword members
|
|
|
*/
|
|
|
typedef struct DsaStatusRawMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
dword sw1; /**< Drive status SW1 in dword type */
|
|
|
dword sw2; /**< Drive status SW2 in dword type */
|
|
|
} DsaStatusRawMode;
|
|
|
|
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusDriveBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusDriveBitMode
|
|
|
* Allow access to drive status with bit members when acces through M63
|
|
|
*/
|
|
|
typedef struct DsaStatusDriveBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
#ifndef DSA_OO_API
|
|
|
unsigned power_on:1; /**< The drive is in power on */
|
|
|
unsigned :2;
|
|
|
unsigned present:1; /**< The drive is present */
|
|
|
unsigned moving:1; /**< The motor is moving */
|
|
|
unsigned in_window:1; /**< The motor's position is in window */
|
|
|
unsigned :2;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :1;
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned :4;
|
|
|
unsigned :7;
|
|
|
unsigned warning:1; /**< Gglobal warning */
|
|
|
unsigned :8;
|
|
|
unsigned :2;
|
|
|
unsigned save_pos:1; /**< Position has been reached */
|
|
|
unsigned :1;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned :3;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :8;
|
|
|
#else /* DSA_OO_API */
|
|
|
unsigned powerOn:1; /* The drive is in power on*/
|
|
|
unsigned :2; /* Reserved */
|
|
|
unsigned present:1; /* The drive is present */
|
|
|
unsigned moving:1; /* The motor is moving */
|
|
|
unsigned inWindow:1; /* The motor's position is in window */
|
|
|
unsigned :2; /* Reserved */
|
|
|
unsigned sequence:1; /* A sequence is running */
|
|
|
unsigned :1; /* Reserved */
|
|
|
unsigned error:1; /* Fatal error */
|
|
|
unsigned trace:1; /* The aquisition of the trace is not finished */
|
|
|
unsigned :4; /* Reserved */
|
|
|
unsigned :7; /* Reserved */
|
|
|
unsigned warning:1; /* Global warning */
|
|
|
unsigned :8; /* Reserved */
|
|
|
unsigned :2;
|
|
|
unsigned savePos:1; /* Position has been reached */
|
|
|
unsigned :1; /* Reserved */
|
|
|
unsigned breakpoint:1; /* Breakpoint is reached */
|
|
|
unsigned :3; /* Reserved */
|
|
|
unsigned user:16; /* User status */
|
|
|
unsigned :8; /* Reserved */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DsaStatusDriveBitMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusDsmaxBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusDsmaxBitMode
|
|
|
* Allow access to dsmax status with bit members when acces through M63
|
|
|
*/
|
|
|
typedef struct DsaStatusDsmaxBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
unsigned :3;
|
|
|
unsigned present:1; /**< The Dsmax is present */
|
|
|
unsigned moving:1; /**< An axis (of ipol group 0 or 1) is moving */
|
|
|
unsigned :3;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :1;
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned ipol0_moving:1; /**< Ipol group 0 is moving */
|
|
|
unsigned ipol1_moving:1; /**< Ipol group 1 is moving */
|
|
|
unsigned :2;
|
|
|
unsigned :7;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :8;
|
|
|
unsigned :4;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned :3;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :8;
|
|
|
} DsaStatusDsmaxBitMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusUltimETBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusUltimETBitMode
|
|
|
* Allow access to UltimET status with bit members when acces through M63
|
|
|
*/
|
|
|
typedef struct DsaStatusUltimETBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
unsigned :3;
|
|
|
unsigned present:1; /**< The Dsmax is present */
|
|
|
unsigned moving:1; /**< An axis (of ipol group 0 or 1) is moving */
|
|
|
unsigned :3;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :1;
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned ipol0_moving:1; /**< Ipol group 0 is moving */
|
|
|
unsigned ipol1_moving:1; /**< Ipol group 1 is moving */
|
|
|
unsigned :2;
|
|
|
unsigned :7;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :8;
|
|
|
unsigned :2;
|
|
|
unsigned transnet_broken:1; /**< Transnet connection broken */
|
|
|
unsigned :1;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned :3;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :8;
|
|
|
} DsaStatusUltimETBitMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusGPModuleBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusGPModuleBitMode
|
|
|
* Allow access to general purpose module status with bit members
|
|
|
*/
|
|
|
typedef struct DsaStatusGPModuleBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
unsigned reserved1:1; /**< Reserved for power on */
|
|
|
unsigned :2;
|
|
|
unsigned present:1; /**< The gp_module is present */
|
|
|
unsigned reserved2:1; /**< Reserved for moving */
|
|
|
unsigned reserved3:1; /**< Reserved for in window */
|
|
|
unsigned :2;
|
|
|
unsigned reserved4:1; /**< Reserved for sequence running */
|
|
|
unsigned :1;
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished*/
|
|
|
unsigned :4;
|
|
|
unsigned :7;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :8;
|
|
|
unsigned :2;
|
|
|
unsigned reserved9:1; /**< Reserved for position has been reached */
|
|
|
unsigned :1;
|
|
|
unsigned reserved8:1; /**< Reserved for breakpoint */
|
|
|
unsigned :3;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :8;
|
|
|
} DsaStatusGPModuleBitMode;
|
|
|
|
|
|
#else /*__BYTE_ORDER == __BIG_ENDIAN*/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusDriveBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusDriveBitMode
|
|
|
* Allow access to drive status with bit members when acces through M63
|
|
|
*/
|
|
|
typedef struct DsaStatusDriveBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
#ifndef DSA_OO_API
|
|
|
unsigned :8;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :7;
|
|
|
unsigned :4;
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned :1;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :2;
|
|
|
unsigned in_window:1; /**< The motor's position is in window */
|
|
|
unsigned moving:1; /**< The motor is moving */
|
|
|
unsigned present:1; /**< The drive is present */
|
|
|
unsigned :2;
|
|
|
unsigned power_on:1; /**< The drive is in power on */
|
|
|
unsigned :8;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :3;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned : 1;
|
|
|
unsigned save_pos:1; /**< Position has been reached */
|
|
|
unsigned : 2;
|
|
|
#else /* DSA_OO_API */
|
|
|
unsigned :8;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :7;
|
|
|
unsigned :4;
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned :1;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :2;
|
|
|
unsigned inWindow:1; /**< Position is in window */
|
|
|
unsigned moving:1; /**< The motor is moving */
|
|
|
unsigned present:1; /**< The drive is present */
|
|
|
unsigned :2;
|
|
|
unsigned powerOn:1; /**< The drive is in power on */
|
|
|
unsigned :8;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :3;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned :1;
|
|
|
unsigned savePos:1; /**< Position has been reached */
|
|
|
unsigned :2;
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DsaStatusDriveBitMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusDsmaxBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusDsmaxBitMode
|
|
|
* Allow access to dsmax status with bit members when acces through M60
|
|
|
*/
|
|
|
typedef struct DsaStatusDsmaxBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
unsigned :8;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :7;
|
|
|
unsigned :2;
|
|
|
unsigned ipol1_moving:1; /**< Ipol group 1 is moving */
|
|
|
unsigned ipol0_moving:1; /**< Ipol group 0 is moving */
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned :1;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :3;
|
|
|
unsigned moving:1; /**< An axis (of ipol group 0 or 1) is moving */
|
|
|
unsigned present:1; /**< The dsmax is present */
|
|
|
unsigned :3;
|
|
|
unsigned :8;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :3;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned :4;
|
|
|
} DsaStatusDsmaxBitMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusUltimETBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusUltimETBitMode
|
|
|
* Allow access to UltimET status with bit members when acces through M60
|
|
|
*/
|
|
|
typedef struct DsaStatusUltimETBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
unsigned :8;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :7;
|
|
|
unsigned :2;
|
|
|
unsigned ipol1_moving:1; /**< Ipol group 1 is moving */
|
|
|
unsigned ipol0_moving:1; /**< Ipol group 0 is moving */
|
|
|
unsigned trace:1; /**< The aquisition of the trace is not finished */
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned :1;
|
|
|
unsigned sequence:1; /**< A sequence is running */
|
|
|
unsigned :3;
|
|
|
unsigned moving:1; /**< An axis (of ipol group 0 or 1) is moving */
|
|
|
unsigned present:1; /**< The UltimET is present */
|
|
|
unsigned :3;
|
|
|
unsigned :8;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :3;
|
|
|
unsigned breakpoint:1; /**< Breakpoint is reached */
|
|
|
unsigned : 1;
|
|
|
unsigned transnet_broken:1; /**< Transnet connection broken */
|
|
|
unsigned : 2;
|
|
|
} DsaStatusUltimETBitMode;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaStatusGPModuleBitMode type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaStatusGPModuleBitMode
|
|
|
* Allow access to general purpose module status with bit members
|
|
|
*/
|
|
|
typedef struct DsaStatusGPModuleBitMode {
|
|
|
size_t size; /**< The size of the structure */
|
|
|
unsigned :8;
|
|
|
unsigned warning:1; /**< Global warning */
|
|
|
unsigned :7;
|
|
|
unsigned :4;
|
|
|
unsigned trace:1; /**< The acquisition of the trace is not finished */
|
|
|
unsigned error:1; /**< Fatal error */
|
|
|
unsigned :1;
|
|
|
unsigned reserved4:1; /**< Reserved for sequence running */
|
|
|
unsigned :2;
|
|
|
unsigned reserved3:1; /**< Reserved for position in window */
|
|
|
unsigned reserved2:1; /**< Reserved for motor is moving */
|
|
|
unsigned present:1; /**< The drive is present */
|
|
|
unsigned :2;
|
|
|
unsigned reserved1:1; /**< Reserved for the drive is in power on */
|
|
|
unsigned :8;
|
|
|
unsigned user:16; /**< User status */
|
|
|
unsigned :3;
|
|
|
unsigned reserved8:1; /**< Reserved for breakpoint*/
|
|
|
unsigned :1;
|
|
|
unsigned reserved9:1; /**< Reserved for position reached*/
|
|
|
unsigned :2;
|
|
|
} DsaStatusGPModuleBitMode;
|
|
|
#endif /*__BYTE_ORDER*/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_STATUS type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @union DSA_STATUS
|
|
|
* Contains status of devices
|
|
|
*/
|
|
|
typedef union DSA_STATUS {
|
|
|
size_t size; /**< The size of this structure */
|
|
|
DsaStatusSWMode sw; /**< Status for SW1/SW2 access. Obsolete */
|
|
|
DsaStatusRawMode raw; /**< Status for raw access. Obsolete */
|
|
|
DsaStatusDriveBitMode drive; /**< Status for drive bit access */
|
|
|
DsaStatusDsmaxBitMode dsmax; /**< Status for dsmax bit access */
|
|
|
DsaStatusUltimETBitMode ultimet; /**< Status for UltimETdsmax bit access */
|
|
|
DsaStatusGPModuleBitMode gp_module; /**< Status for gp module bit access */
|
|
|
} DSA_STATUS;
|
|
|
|
|
|
#define DsaStatus DSA_STATUS
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_INFO type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_INFO
|
|
|
* Device info parameters monitoring structure
|
|
|
*/
|
|
|
typedef struct DSA_INFO {
|
|
|
size_t size; /**< Size of this structure */
|
|
|
#ifndef DSA_OO_API
|
|
|
int info_product_number; /**< Product number */
|
|
|
int info_boot_revision; /**< Boot revision */
|
|
|
dword info_serial_number; /**< Serial number */
|
|
|
dword info_soft_version; /**< Software version */
|
|
|
dword info_p_soft_build_time; /**< Position software build time */
|
|
|
dword info_c_soft_build_time; /**< Current software build time */
|
|
|
dword info_product_string[8]; /**< Product string */
|
|
|
#else /* DSA_OO_API */
|
|
|
int infoProductNumber; /**< Product number */
|
|
|
int infoBootRevision; /**< Boot revision */
|
|
|
dword infoSerialNumber; /**< Serial number */
|
|
|
dword infoSoftVersion; /**< Software version */
|
|
|
dword infoPSoftBuildTime; /**< Position software build time */
|
|
|
dword infoCSoftBuildTime; /**< Current software build time */
|
|
|
dword infoProductString[8]; /**< Product string */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DSA_INFO;
|
|
|
|
|
|
#define DsaInfo DSA_INFO
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_X_INFO type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_X_INFO
|
|
|
* Extension card info parameters monitoring structure
|
|
|
*/
|
|
|
typedef struct DSA_X_INFO {
|
|
|
size_t size; /**< Size of this structure */
|
|
|
#ifndef DSA_OO_API
|
|
|
int x_info_product_number; /**< Extension card info product number */
|
|
|
int x_info_boot_revision; /**< Extension card info boot revision */
|
|
|
dword x_info_serial_number; /**< Extension card info serial number */
|
|
|
dword x_info_soft_version; /**< Extension card info software version */
|
|
|
dword x_info_soft_build_time; /**< Extension card info software build time */
|
|
|
dword x_info_product_string[4]; /**< Extension card info product string */
|
|
|
#else /* DSA_OO_API */
|
|
|
int xInfoProductNumber; /**< Extension card info product number */
|
|
|
int xInfoBootRevision; /**< Extension card info boot revision */
|
|
|
dword xInfoSerialNumber; /**< Extension card info serial number */
|
|
|
dword xInfoSoftVersion; /**< Extension card info software version */
|
|
|
dword xInfoSoftBuildTime; /**< Extension card info software build time */
|
|
|
dword xInfoProductString[4]; /**< Extension card info product string */
|
|
|
#endif /* DSA_OO_API */
|
|
|
} DSA_X_INFO;
|
|
|
|
|
|
#define DsaXInfo DSA_X_INFO
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_RTV_HANDLER type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/*Type of RTV handler called at each cyclic UltimET interrupt*/
|
|
|
/*Only on AccurET family connected through UltimET*/
|
|
|
typedef void (DSA_CALLBACK *DSA_RTV_HANDLER)(DSA_DSMAX *ultimet, int nr, int nb_read, DSA_RTV_DATA **read_rtv, int nb_write, DSA_RTV_DATA **write_rtv, void *user);
|
|
|
//#define DsaRTVHandler DSA_RTV_HANDLER
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_RTM_VAL type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_RTM_VAL
|
|
|
* Contains realtime monitoring
|
|
|
*/
|
|
|
typedef struct DSA_RTM_VAL {
|
|
|
long val0; /**< The first monitoring */
|
|
|
long val1; /**< The second monitoring */
|
|
|
} DSA_RTM_VAL;
|
|
|
#define DsaRTMVal DSA_RTM_VAL
|
|
|
|
|
|
#define DSA_MAX_RTM 16 /**< Maximal number of drives by using realtime CHANNEL */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_RTM_TABLE type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_RTM_TABLE
|
|
|
* Contains realtime monitoring in a table
|
|
|
*/
|
|
|
typedef struct DSA_RTM_TABLE {
|
|
|
size_t size; /**< The size of this structure */
|
|
|
DSA_RTM_VAL mon[16]; /**< The monitoring table */
|
|
|
} DSA_RTM_TABLE;
|
|
|
#define DsaRTMTable DSA_RTM_TABLE
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_RTM_STRUCT type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_RTM_STRUCT
|
|
|
* Contains realtime monitoring in structure
|
|
|
*/
|
|
|
typedef struct DSA_RTM_STRUCT {
|
|
|
size_t size; /**< The size of this structure */
|
|
|
long axis0_m0; /**< The first realtime monitoring value of 1st axis */
|
|
|
long axis0_m1; /**< The second realtime monitoring value of 1st axis */
|
|
|
long axis1_m0; /**< The first realtime monitoring value of 2nd axis */
|
|
|
long axis1_m1; /**< The second realtime monitoring value of 2nd axis */
|
|
|
long axis2_m0; /**< The first realtime monitoring value of 3rd axis */
|
|
|
long axis2_m1; /**< The second realtime monitoring value of 3rd axis */
|
|
|
long axis3_m0; /**< The first realtime monitoring value of 4th axis */
|
|
|
long axis3_m1; /**< The second realtime monitoring value of 4th axis */
|
|
|
long axis4_m0; /**< The first realtime monitoring value of 5th axis */
|
|
|
long axis4_m1; /**< The second realtime monitoring value of 5th axis */
|
|
|
long axis5_m0; /**< The first realtime monitoring value of 6th axis */
|
|
|
long axis5_m1; /**< The second realtime monitoring value of 6th axis */
|
|
|
long axis6_m0; /**< The first realtime monitoring value of 7th axis */
|
|
|
long axis6_m1; /**< The second realtime monitoring value of 7th axis */
|
|
|
long axis7_m0; /**< The first realtime monitoring value of 8th axis */
|
|
|
long axis7_m1; /**< The second realtime monitoring value of 8th axis */
|
|
|
long axis8_m0; /**< The first realtime monitoring value of 9th axis */
|
|
|
long axis8_m1; /**< The second realtime monitoring value of 9th axis */
|
|
|
long axis9_m0; /**< The first realtime monitoring value of 10th axis */
|
|
|
long axis9_m1; /**< The second realtime monitoring value of 10th axis */
|
|
|
long axis10_m0; /**< The first realtime monitoring value of 11th axis */
|
|
|
long axis10_m1; /**< The second realtime monitoring value of 11th axis */
|
|
|
long axis11_m0; /**< The first realtime monitoring value of 12th axis */
|
|
|
long axis11_m1; /**< The second realtime monitoring value of 12th axis */
|
|
|
long axis12_m0; /**< The first realtime monitoring value of 13th axis */
|
|
|
long axis12_m1; /**< The second realtime monitoring value of 13th axis */
|
|
|
long axis13_m0; /**< The first realtime monitoring value of 14th axis */
|
|
|
long axis13_m1; /**< The second realtime monitoring value of 14th axis */
|
|
|
long axis14_m0; /**< The first realtime monitoring value of 15th axis */
|
|
|
long axis14_m1; /**< The second realtime monitoring value of 15th axis */
|
|
|
long axis15_m0; /**< The first realtime monitoring value of 16th axis */
|
|
|
long axis15_m1; /**< The second realtime monitoring value of 16th axis */
|
|
|
} DSA_RTM_STRUCT;
|
|
|
#define DsaRTMStruct DSA_RTM_STRUCT
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_RTM type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @union DSA_RTM
|
|
|
* Getted realtime monitoring structure
|
|
|
*/
|
|
|
typedef union DSA_RTM {
|
|
|
size_t size; /**< Size of this structure */
|
|
|
DSA_RTM_STRUCT monStruct; /**< Access to realtime monitoring through structure */
|
|
|
DSA_RTM_TABLE monTable; /**< Access to realtime monitoring through table */
|
|
|
} DSA_RTM;
|
|
|
#define DsaRTM DSA_RTM
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_TRAJECTORY_HANDLER type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/*Type of trajectory generator function called at each interrupt*/
|
|
|
/*Only on DSC family connected through DSTEB3*/
|
|
|
typedef void (DSA_CALLBACK *DSA_TRAJECTORY_HANDLER)(DSA_RTM *pts);
|
|
|
#define DsaTrajectoryHandler DSA_TRAJECTORY_HANDLER
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* asynchronous handlers
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
typedef void (DSA_CALLBACK *DSA_HANDLER)(DSA_DEVICE_BASE *dev, int err, void *param);
|
|
|
typedef void (DSA_CALLBACK *DSA_INT_HANDLER)(DSA_DEVICE *dev, int err, void *param, int val);
|
|
|
typedef void (DSA_CALLBACK *DSA_LONG_HANDLER)(DSA_DEVICE *dev, int err, void *param, long val);
|
|
|
typedef void (DSA_CALLBACK *DSA_INT64_HANDLER)(DSA_DEVICE *dev, int err, void *param, eint64 val);
|
|
|
typedef void (DSA_CALLBACK *DSA_DWORD_HANDLER)(DSA_DEVICE *dev, int err, void *param, dword val);
|
|
|
typedef void (DSA_CALLBACK *DSA_FLOAT_HANDLER)(DSA_DEVICE *dev, int err, void *param, float val);
|
|
|
typedef void (DSA_CALLBACK *DSA_DOUBLE_HANDLER)(DSA_DEVICE *dev, int err, void *param, double val);
|
|
|
typedef void (DSA_CALLBACK *DSA_STATUS_HANDLER)(DSA_DEVICE *dev, int err, void *param, const DSA_STATUS *status);
|
|
|
typedef void (DSA_CALLBACK *DSA_2INT_HANDLER)(DSA_DEVICE *dev, int err, void *param, int val1, int val2);
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaId type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaId
|
|
|
* generic command parameter
|
|
|
*/
|
|
|
typedef union DsaId {
|
|
|
int i;
|
|
|
eint64 i64;
|
|
|
float f;
|
|
|
double d; /**< also used when conv != 0 */
|
|
|
} DsaId;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_COMMAND_PARAM type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_COMMAND_PARAM
|
|
|
* Generic command parameter
|
|
|
*/
|
|
|
typedef struct DSA_COMMAND_PARAM {
|
|
|
int typ; /**< Parameter type */
|
|
|
int conv; /**< Coenversion index, zero means no conversion */
|
|
|
DsaId val; /**< Value of parameter */
|
|
|
} DSA_COMMAND_PARAM;
|
|
|
#define DsaCommandParam DSA_COMMAND_PARAM
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDim type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DsaDim
|
|
|
* Dimension of interpolation structure
|
|
|
*/
|
|
|
typedef struct DsaDim {
|
|
|
double x; /**< X axis*/
|
|
|
double y; /**< Y axis */
|
|
|
double z; /**< Z axis */
|
|
|
double theta; /**< Theta axis */
|
|
|
} DsaDim;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDimArray type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @union DsaDimDArray
|
|
|
* Allows access to parameter through DsaDim structure or array of double
|
|
|
*/
|
|
|
typedef union DsaDimDArray {
|
|
|
DsaDim dim; /**< Access through DsaDim structure */
|
|
|
double array[4]; /**< Access through array of double */
|
|
|
} DsaDimDArray;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDimIArray type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @union DsaDimIArray
|
|
|
* Allows access to parameter through DsaDim structure or array of integer
|
|
|
*/
|
|
|
typedef union DsaDimIArray {
|
|
|
int array[4]; /**< Access through array of int */
|
|
|
} DsaDimIArray;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_VECTOR type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_VECTOR
|
|
|
* Vector
|
|
|
*/
|
|
|
typedef struct DSA_VECTOR {
|
|
|
size_t size; /**< Size of this structure */
|
|
|
int reserved; /**< Reserved for compatibility algnment 8 bytes */
|
|
|
DsaDimDArray val; /**< The value of the axis */
|
|
|
} DSA_VECTOR;
|
|
|
|
|
|
#define DsaVector DSA_VECTOR
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA_VECTOR_TYP type
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
/**
|
|
|
* @struct DSA_VECTOR_TYP
|
|
|
* Vector Typ
|
|
|
*/
|
|
|
typedef struct DSA_VECTOR_TYP {
|
|
|
size_t size; /**< Size of this structure */
|
|
|
int reserved; /**< Reserved for compatibility algnment 8 bytes */
|
|
|
DsaDimIArray val; /**< The typ of the values of the axis */
|
|
|
} DSA_VECTOR_TYP;
|
|
|
|
|
|
#define DsaVectorTyp DSA_VECTOR_TYP
|
|
|
#define DSA_INT_VECTOR DSA_VECTOR_TYP
|
|
|
#define DsaIntVector DSA_VECTOR_TYP
|
|
|
|
|
|
|
|
|
/**********************************************************************************************************/
|
|
|
/*- PROTOTYPES */
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
/**
|
|
|
* @addtogroup DSAAll
|
|
|
* @{
|
|
|
*/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* special functions - synchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_S
|
|
|
int _DSA_EXPORT dsa_power_on_s(DSA_DRIVE_BASE *grp, long timeout);
|
|
|
int _DSA_EXPORT dsa_power_off_s(DSA_DRIVE_BASE *grp, long timeout);
|
|
|
int _DSA_EXPORT dsa_new_setpoint_s(DSA_DRIVE_BASE *grp, int sidx, dword flags, long timeout);
|
|
|
int _DSA_EXPORT dsa_change_setpoint_s(DSA_DRIVE_BASE *grp, int sidx, dword flags, long timeout);
|
|
|
int _DSA_EXPORT dsa_quick_stop_s(DSA_DRIVE_BASE *grp, int mode, dword flags, long timeout);
|
|
|
int _DSA_EXPORT dsa_homing_start_s(DSA_DRIVE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_warning_code_s(DSA_DEVICE *dev, int *code, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_s(DSA_DEVICE_BASE *grp, int cmd, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_d_s(DSA_DEVICE_BASE *grp, int cmd, int typ1, long par1, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_i_s(DSA_DEVICE_BASE *grp, int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_dd_s(DSA_DEVICE_BASE *grp, int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_id_s(DSA_DEVICE_BASE *grp, int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_di_s(DSA_DEVICE_BASE *grp, int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_ii_s(DSA_DEVICE_BASE *grp, int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_command_x_s(DSA_DEVICE_BASE *grp, int cmd, DSA_COMMAND_PARAM *params, int count, bool fast, bool ereport, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_profiled_movement_s(DSA_DRIVE_BASE *grp, double pos, double speed, double acc, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_relative_profiled_movement_s(DSA_DRIVE_BASE *grp, double relative_pos, long timeout);
|
|
|
|
|
|
int _DSA_EXPORT dsa_get_register_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, long *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_register_int32_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, long *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_register_int64_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, eint64 *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_register_float32_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, float *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_register_float64_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_float_register_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, float *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_array_s(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_array_int32_s(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_array_int64_s(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_array_float32_s(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_array_float64_s(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_register_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, long val, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_register_int32_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, long val, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_register_int64_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, eint64 val, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_register_float32_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, float val, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_register_float64_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, double val, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_float_register_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, float val, long timeout);
|
|
|
|
|
|
int _DSA_EXPORT dsa_set_array_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_array_int32_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_array_int64_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_array_float32_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_array_float64_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout);
|
|
|
|
|
|
int _DSA_EXPORT dsa_get_iso_register_s(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, double *val, int conv, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_iso_array_s(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_iso_register_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, double val, int conv, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_iso_array_s(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_begin_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_end_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_begin_concatenation_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_end_concatenation_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_line_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_cw_r2d_s(DSA_IPOL_GROUP *igrp, double x, double y, double r, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_ccw_r2d_s(DSA_IPOL_GROUP *igrp, double x, double y, double r, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_velocity_s(DSA_IPOL_GROUP *igrp, double velocity, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_acceleration_s(DSA_IPOL_GROUP *igrp, double acc, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_deceleration_s(DSA_IPOL_GROUP *igrp, double dec, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_jerk_time_s(DSA_IPOL_GROUP *igrp, double jerk_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_quick_stop_s(DSA_IPOL_GROUP *igrp, int mode, dword flags, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_continue_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_reset_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_pvt_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_VECTOR *velocity, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_pt_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_mark_s(DSA_IPOL_GROUP *igrp, long number, long operation, long op_param, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_mark_2param_s(DSA_IPOL_GROUP *igrp, long number, long operation, long op_param1, long op_param2, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_set_velocity_rate_s(DSA_IPOL_GROUP *igrp, double rate, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_cw_c2d_s(DSA_IPOL_GROUP *igrp, double x, double y, double cx, double cy, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_ccw_c2d_s(DSA_IPOL_GROUP *igrp, double x, double y, double cx, double cy, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_line_2d_s(DSA_IPOL_GROUP *igrp, double x, double y, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_wait_movement_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_prepare_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_pvt_update_s(DSA_IPOL_GROUP *igrp, int depth, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_pvt_reg_typ_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_VECTOR_TYP destTyp, DSA_VECTOR *velocity, DSA_VECTOR_TYP velocityTyp, double time, int timeTyp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_set_lkt_speed_ratio_s(DSA_IPOL_GROUP *igrp, double value, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_set_lkt_cyclic_mode_s(DSA_IPOL_GROUP *igrp, bool active, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_set_lkt_relative_mode_s(DSA_IPOL_GROUP *igrp, bool active, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_lkt_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_INT_VECTOR *lkt_number, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_wait_mark_s(DSA_IPOL_GROUP *igrp, int mark, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_uline_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_uline_2d_s(DSA_IPOL_GROUP *igrp, double x, double y, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_disable_uconcatenation_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_set_urelative_mode_s(DSA_IPOL_GROUP *igrp, bool active, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_uspeed_axis_mask_s(DSA_IPOL_GROUP *igrp, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_uspeed_s(DSA_IPOL_GROUP *igrp, double speed, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_utime_s(DSA_IPOL_GROUP *igrp, double acc_time, double jerk_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_translate_matrix_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *trans, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_scale_matrix_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *scale, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_rotate_matrix_s(DSA_IPOL_GROUP *igrp, int plan, double degree, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_translate_matrix_2d_s(DSA_IPOL_GROUP *igrp, double x, double y, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_scale_matrix_2d_s(DSA_IPOL_GROUP *igrp, double x, double y, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_shear_matrix_s(DSA_IPOL_GROUP *igrp, int sheared_axis, double axis1_shearing, double axis2_shearing, double axis3_shearing, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_lock_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_unlock_s(DSA_IPOL_GROUP *igrp, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_status_equal_s(DSA_DEVICE *drv, DSA_STATUS *mask, DSA_STATUS *ref, DSA_STATUS *status, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_status_not_equal_s(DSA_DEVICE *drv, DSA_STATUS *mask, DSA_STATUS *ref, DSA_STATUS *status, long timeout);
|
|
|
int _DSA_EXPORT dsa_grp_wait_and_status_equal_s(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, long timeout);
|
|
|
int _DSA_EXPORT dsa_grp_wait_and_status_not_equal_s(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, long timeout);
|
|
|
int _DSA_EXPORT dsa_gantry_wait_and_status_equal_s(DSA_GANTRY *gantry, DSA_STATUS *mask, DSA_STATUS *ref, long timeout);
|
|
|
int _DSA_EXPORT dsa_gantry_wait_and_status_not_equal_s(DSA_GANTRY *gantry, DSA_STATUS *mask, DSA_STATUS *ref, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_status_change_s(DSA_DEVICE *drv, DSA_STATUS *mask, DSA_STATUS *status, long timeout);
|
|
|
int _DSA_EXPORT dsa_grp_wait_or_status_equal_s(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, long timeout);
|
|
|
int _DSA_EXPORT dsa_grp_wait_or_status_not_equal_s(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_mvt_s(DSA_DEVICE_BASE *obj, double time, bool endm, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_pos_s(DSA_DEVICE_BASE *obj, double time, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_dev_s(DSA_DEVICE_BASE *obj, double time, long level, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_iso_s(DSA_DEVICE_BASE *obj, double time, void *level, int conv, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_immediate_s(DSA_DEVICE_BASE *obj, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_trace_acquisition_s(DSA_DEVICE_BASE *obj, int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout);
|
|
|
int _DSA_EXPORT dsa_sync_trace_enable_s(DSA_DEVICE_BASE *obj, bool enable, long timeout);
|
|
|
int _DSA_EXPORT dsa_sync_trace_force_trigger_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_error_code_s(DSA_DEVICE *obj, int *code, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_acquisition_acquire_s(DSA_ACQUISITION *acq, int timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_set_abs_mode_s(DSA_IPOL_GROUP *igrp, bool active, long timeout);
|
|
|
int _DSA_EXPORT dsa_ipol_abs_coords_s(DSA_IPOL_GROUP *igrp, DSA_VECTOR *pos, long timeout);
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* special functions - asynchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_A
|
|
|
int _DSA_EXPORT dsa_power_on_a(DSA_DRIVE_BASE *grp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_power_off_a(DSA_DRIVE_BASE *grp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_new_setpoint_a(DSA_DRIVE_BASE *grp, int sidx, dword flags, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_change_setpoint_a(DSA_DRIVE_BASE *grp, int sidx, dword flags, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_quick_stop_a(DSA_DRIVE_BASE *grp, int mode, dword flags, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_homing_start_a(DSA_DRIVE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_warning_code_a(DSA_DEVICE *dev, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_a(DSA_DEVICE_BASE *grp, int cmd, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_d_a(DSA_DEVICE_BASE *grp, int cmd, int typ1, long par1, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_i_a(DSA_DEVICE_BASE *grp, int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_dd_a(DSA_DEVICE_BASE *grp, int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_id_a(DSA_DEVICE_BASE *grp, int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_di_a(DSA_DEVICE_BASE *grp, int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_ii_a(DSA_DEVICE_BASE *grp, int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_command_x_a(DSA_DEVICE_BASE *grp, int cmd, DSA_COMMAND_PARAM *params, int count, bool fast, bool ereport, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_start_profiled_movement_a(DSA_DRIVE_BASE *grp, double pos, double speed, double acc, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_start_relative_profiled_movement_a(DSA_DRIVE_BASE *grp, double relative_pos, DSA_HANDLER handler, void *param);
|
|
|
|
|
|
int _DSA_EXPORT dsa_get_register_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int kind, DSA_LONG_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_register_int32_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int kind, DSA_LONG_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_register_int64_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int kind, DSA_INT64_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_register_float32_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int kind, DSA_FLOAT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_register_float64_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_float_register_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
|
|
|
int _DSA_EXPORT dsa_get_array_a(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_array_int32_a(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_array_int64_a(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_array_float32_a(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_array_float64_a(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, DSA_HANDLER handler, void *param);
|
|
|
|
|
|
int _DSA_EXPORT dsa_set_register_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, long val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_register_int32_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, long val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_register_int64_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, eint64 val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_register_float32_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, float val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_register_float64_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, double val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_float_register_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, float val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_array_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_array_int32_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_array_int64_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_array_float32_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_array_float64_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DSA_HANDLER handler, void *param);
|
|
|
|
|
|
int _DSA_EXPORT dsa_get_iso_register_a(DSA_DEVICE *dev, int typ, unsigned idx, int sidx, int conv, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_iso_array_a(DSA_DEVICE *dev, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_iso_register_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, int sidx, double val, int conv, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_iso_array_a(DSA_DEVICE_BASE *grp, int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_begin_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_end_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_begin_concatenation_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_end_concatenation_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_line_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_cw_r2d_a(DSA_IPOL_GROUP *igrp, double x, double y, double r, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_ccw_r2d_a(DSA_IPOL_GROUP *igrp, double x, double y, double r, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_velocity_a(DSA_IPOL_GROUP *igrp, double velocity, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_acceleration_a(DSA_IPOL_GROUP *igrp, double acc, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_deceleration_a(DSA_IPOL_GROUP *igrp, double dec, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_tan_jerk_time_a(DSA_IPOL_GROUP *igrp, double jerk_time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_quick_stop_a(DSA_IPOL_GROUP *igrp, int mode, dword flags, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_continue_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_reset_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_pvt_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_VECTOR *velocity, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_pt_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_mark_a(DSA_IPOL_GROUP *igrp, long number, long operation, long op_param, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_mark_2param_a(DSA_IPOL_GROUP *igrp, long number, long operation, long op_param1, long op_param2, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_set_velocity_rate_a(DSA_IPOL_GROUP *igrp, double rate, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_cw_c2d_a(DSA_IPOL_GROUP *igrp, double x, double y, double cx, double cy, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_circle_ccw_c2d_a(DSA_IPOL_GROUP *igrp, double x, double y, double cx, double cy, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_line_2d_a(DSA_IPOL_GROUP *igrp, double x, double y, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_wait_movement_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_prepare_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_pvt_update_a(DSA_IPOL_GROUP *igrp, int depth, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_pvt_reg_typ_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_VECTOR_TYP destTyp, DSA_VECTOR *velocity, DSA_VECTOR_TYP velocityTyp, double time, int timeTyp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_set_lkt_speed_ratio_a(DSA_IPOL_GROUP *igrp, double value, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_set_lkt_cyclic_mode_a(DSA_IPOL_GROUP *igrp, bool active, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_set_lkt_relative_mode_a(DSA_IPOL_GROUP *igrp, bool active, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_lkt_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_INT_VECTOR *lkt_number, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_wait_mark_a(DSA_IPOL_GROUP *igrp, int mark, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_uline_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *dest, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_uline_2d_a(DSA_IPOL_GROUP *igrp, double x, double y, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_disable_uconcatenation_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_set_urelative_mode_a(DSA_IPOL_GROUP *igrp, bool active, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_uspeed_axis_mask_a(DSA_IPOL_GROUP *igrp, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_uspeed_a(DSA_IPOL_GROUP *igrp, double speed, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_utime_a(DSA_IPOL_GROUP *igrp, double acc_time, double jerk_time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_translate_matrix_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *trans, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_scale_matrix_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *scale, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_rotate_matrix_a(DSA_IPOL_GROUP *igrp, int plan, double degree, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_translate_matrix_2d_a(DSA_IPOL_GROUP *igrp, double x, double y, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_scale_matrix_2d_a(DSA_IPOL_GROUP *igrp, double x, double y, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_shear_matrix_a(DSA_IPOL_GROUP *igrp, int sheared_axis, double axis1_shearing, double axis2_shearing, double axis3_shearing, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_lock_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_unlock_a(DSA_IPOL_GROUP *igrp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_status_equal_a(DSA_DEVICE *drv, DSA_STATUS *mask, DSA_STATUS *ref, DSA_STATUS_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_status_not_equal_a(DSA_DEVICE *drv, DSA_STATUS *mask, DSA_STATUS *ref, DSA_STATUS_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_grp_wait_and_status_equal_a(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_grp_wait_and_status_not_equal_a(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_gantry_wait_and_status_equal_a(DSA_GANTRY *gantry, DSA_STATUS *mask, DSA_STATUS *ref, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_gantry_wait_and_status_not_equal_a(DSA_GANTRY *gantry, DSA_STATUS *mask, DSA_STATUS *ref, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_status_change_a(DSA_DEVICE *drv, DSA_STATUS *mask, DSA_STATUS_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_grp_wait_or_status_equal_a(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_grp_wait_or_status_not_equal_a(DSA_DEVICE_GROUP *grp, DSA_STATUS *mask, DSA_STATUS *ref, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_mvt_a(DSA_DEVICE_BASE *obj, double time, bool endm, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_pos_a(DSA_DEVICE_BASE *obj, double time, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_dev_a(DSA_DEVICE_BASE *obj, double time, long level, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_iso_a(DSA_DEVICE_BASE *obj, double time, void *level, int conv, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trace_mode_immediate_a(DSA_DEVICE_BASE *obj, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_trace_acquisition_a(DSA_DEVICE_BASE *obj, int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_sync_trace_enable_a(DSA_DEVICE_BASE *obj, bool enable, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_sync_trace_force_trigger_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_error_code_a(DSA_DEVICE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_acquisition_acquire_a(DSA_ACQUISITION *acq, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_set_abs_mode_a(DSA_IPOL_GROUP *igrp, bool active, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_ipol_abs_coords_a(DSA_IPOL_GROUP *igrp, DSA_VECTOR *pos, DSA_HANDLER handler, void *param);
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* special functions - others
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
int _DSA_EXPORT dsa_open_e(DSA_DEVICE *dev, ETB *etb, int axis);
|
|
|
int _DSA_EXPORT dsa_etcom_open_e(DSA_DEVICE *dev, ETB *etb, int axis);
|
|
|
int _DSA_EXPORT dsa_open_u(DSA_DEVICE *dev, char_cp url);
|
|
|
int _DSA_EXPORT dsa_open_ef(DSA_DEVICE *dev, ETB *etb, int axis, dword flags);
|
|
|
int _DSA_EXPORT dsa_etcom_open_ef(DSA_DEVICE *dev, ETB *etb, int axis, dword flags);
|
|
|
int _DSA_EXPORT dsa_reset(DSA_DEVICE *dev);
|
|
|
int _DSA_EXPORT dsa_close(DSA_DEVICE *dev);
|
|
|
int _DSA_EXPORT dsa_get_etb_bus(DSA_DEVICE *dev, ETB **etb);
|
|
|
int _DSA_EXPORT dsa_get_dmd_data(DSA_DEVICE *dev, DMD **dmd);
|
|
|
int _DSA_EXPORT dsa_get_etb_axis(DSA_DEVICE *dev, int *axis);
|
|
|
int _DSA_EXPORT dsa_etcom_get_etb_axis(DSA_DEVICE *dev, int *axis);
|
|
|
int _DSA_EXPORT dsa_create_drive(DSA_DRIVE **rdrv);
|
|
|
int _DSA_EXPORT dsa_create_dsmax(DSA_DSMAX **rdsmax);
|
|
|
int _DSA_EXPORT dsa_destroy(DSA_DEVICE_BASE **rdev);
|
|
|
int _DSA_EXPORT dsa_is_open(DSA_DEVICE *dev, bool *is_open);
|
|
|
int _DSA_EXPORT dsa_share(DSA_DEVICE_BASE *dsa);
|
|
|
int _DSA_EXPORT dsa_create_auto_e(DSA_DEVICE **rdev, ETB *etb, int axis);
|
|
|
int _DSA_EXPORT dsa_etcom_create_auto_e(DSA_DEVICE **rdev, ETB *etb, int axis);
|
|
|
int _DSA_EXPORT dsa_create_auto_o(DSA_DEVICE **rdev, int prod);
|
|
|
int _DSA_EXPORT dsa_create_gp_module(DSA_GP_MODULE **rgp_module);
|
|
|
int _DSA_EXPORT dsa_get_motor_typ(DSA_DEVICE *dev);
|
|
|
int _DSA_EXPORT dsa_get_family(DSA_DEVICE_BASE *dev, DMD_FAMILY *family);
|
|
|
dword _DSA_EXPORT dsa_get_version(void);
|
|
|
time_t _DSA_EXPORT dsa_get_build_time(void);
|
|
|
dword _DSA_EXPORT dsa_get_timer(void);
|
|
|
char_cp _DSA_EXPORT dsa_translate_error(int code);
|
|
|
int _DSA_EXPORT dsa_set_prio(int prio);
|
|
|
dword _DSA_EXPORT dsa_get_edi_version(void);
|
|
|
int _DSA_EXPORT dsa_get_new_gate (DSA_DEVICE_BASE *dsa, int uid, int gate_type, dword *gate_nr);
|
|
|
int _DSA_EXPORT dsa_set_gate (DSA_DEVICE_BASE *dsa, dword gate_nr);
|
|
|
int _DSA_EXPORT dsa_clear_gate (DSA_DEVICE_BASE *dsa, int uid, dword gate_nr);
|
|
|
int _DSA_EXPORT dsa_get_error_text(DSA_DEVICE *dev, char_p text, int size, int code);
|
|
|
int _DSA_EXPORT dsa_get_warning_text(DSA_DEVICE *dev, char_p text, int size, int code);
|
|
|
char_cp _DSA_EXPORT dsa_translate_edi_error(int code);
|
|
|
int _DSA_EXPORT dsa_convert_to_iso(DSA_DEVICE *dev, double *iso, long inc, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_int32_to_iso(DSA_DEVICE *dev, double *iso, long inc, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_int64_to_iso(DSA_DEVICE *dev, double *iso, eint64 inc, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_float32_to_iso(DSA_DEVICE *dev, double *iso, float inc, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_float64_to_iso(DSA_DEVICE *dev, double *iso, double inc, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_from_iso(DSA_DEVICE *dev, long *inc, double iso, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_int32_from_iso(DSA_DEVICE *dev, long *inc, double iso, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_int64_from_iso(DSA_DEVICE *dev, eint64 *inc, double iso, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_float32_from_iso(DSA_DEVICE *dev, float *inc, double iso, int conv);
|
|
|
int _DSA_EXPORT dsa_convert_float64_from_iso(DSA_DEVICE *dev, double *inc, double iso, int conv);
|
|
|
int _DSA_EXPORT dsa_get_inc_to_iso_factor(DSA_DEVICE *dev, int conv, double *factor);
|
|
|
int _DSA_EXPORT dsa_get_rtm_mon(DSA_DEVICE_BASE *grp, DSA_RTM *rtm);
|
|
|
int _DSA_EXPORT dsa_init_rtm_fct(DSA_DEVICE_BASE *grp);
|
|
|
int _DSA_EXPORT dsa_start_rtm(DSA_DEVICE_BASE *grp, DSA_TRAJECTORY_HANDLER fct);
|
|
|
int _DSA_EXPORT dsa_stop_rtm(DSA_DEVICE_BASE *grp);
|
|
|
int _DSA_EXPORT dsa_diag(char_cp file_name, int line, int err, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_sdiag(char_p str, char_cp file_name, int line, int err, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_fdiag(char_cp output_file_name, char_cp file_name, int line, int err, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_ext_diag(char_cp file_name, int line, int err, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_ext_sdiag(int size, char_p str, char_cp file_name, int line, int err, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_ext_fdiag(char_cp output_file_name, char_cp file_name, int line, int err, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_create_device_group(DSA_DEVICE_GROUP **rgrp, int size);
|
|
|
int _DSA_EXPORT dsa_create_drive_group(DSA_DRIVE_GROUP **rgrp, int size);
|
|
|
int _DSA_EXPORT dsa_create_dsmax_group(DSA_DSMAX_GROUP **rgrp, int size);
|
|
|
int _DSA_EXPORT dsa_create_ipol_group(DSA_IPOL_GROUP **rgrp, int size);
|
|
|
int _DSA_EXPORT dsa_get_group_size(DSA_DEVICE_GROUP *grp, int *size);
|
|
|
int _DSA_EXPORT dsa_set_group_item(DSA_DEVICE_GROUP *grp, int pos, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_get_group_item(DSA_DEVICE_GROUP *grp, int pos, DSA_DEVICE_BASE **rdev);
|
|
|
int _DSA_EXPORT dsa_add_group_item(DSA_DEVICE_GROUP *grp, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_set_dsmax(DSA_IPOL_GROUP *grp, DSA_DSMAX *dsmax);
|
|
|
int _DSA_EXPORT dsa_get_dsmax(DSA_IPOL_GROUP *grp, DSA_DSMAX **dsmax);
|
|
|
bool _DSA_EXPORT dsa_is_valid_device(DSA_DEVICE *dev);
|
|
|
bool _DSA_EXPORT dsa_is_valid_drive(DSA_DRIVE *drv);
|
|
|
bool _DSA_EXPORT dsa_is_valid_dsmax(DSA_DSMAX *dsmax);
|
|
|
bool _DSA_EXPORT dsa_is_valid_device_group(DSA_DEVICE_GROUP *grp);
|
|
|
bool _DSA_EXPORT dsa_is_valid_drive_group(DSA_DRIVE_GROUP *grp);
|
|
|
bool _DSA_EXPORT dsa_is_valid_dsmax_group(DSA_DSMAX_GROUP *grp);
|
|
|
bool _DSA_EXPORT dsa_is_valid_ipol_group(DSA_IPOL_GROUP *grp);
|
|
|
bool _DSA_EXPORT dsa_is_valid_device_base(DSA_DEVICE_BASE *dev);
|
|
|
bool _DSA_EXPORT dsa_is_valid_drive_base(DSA_DRIVE_BASE *dev);
|
|
|
bool _DSA_EXPORT dsa_is_valid_dsmax_base(DSA_DSMAX_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_create_gantry(DSA_GANTRY **gantry);
|
|
|
bool _DSA_EXPORT dsa_is_valid_gantry(DSA_GANTRY *gantry);
|
|
|
int _DSA_EXPORT dsa_gantry_get_error_code(DSA_GANTRY *gantry, int *code, int *axis, int kind);
|
|
|
int _DSA_EXPORT dsa_create_gp_module_group(DSA_GP_MODULE_GROUP **rgrp, int size);
|
|
|
bool _DSA_EXPORT dsa_is_valid_gp_module(DSA_GP_MODULE *gp_module);
|
|
|
bool _DSA_EXPORT dsa_is_valid_gp_module_group(DSA_GP_MODULE_GROUP *grp);
|
|
|
bool _DSA_EXPORT dsa_is_valid_gp_module_base(DSA_GP_MODULE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_get_info(DSA_DEVICE *dev, DSA_INFO *info);
|
|
|
bool _DSA_EXPORT dsa_is_ipol_in_progress(DSA_IPOL_GROUP *igrp);
|
|
|
int _DSA_EXPORT dsa_get_status(DSA_DEVICE *dev, DSA_STATUS *status);
|
|
|
int _DSA_EXPORT dsa_cancel_status_wait(DSA_DEVICE_BASE *grp);
|
|
|
int _DSA_EXPORT dsa_gantry_cancel_status_wait(DSA_GANTRY *gantry);
|
|
|
int _DSA_EXPORT dsa_gantry_get_and_status(DSA_GANTRY *gantry, DSA_STATUS *status);
|
|
|
int _DSA_EXPORT dsa_gantry_get_or_status(DSA_GANTRY *gantry, DSA_STATUS *status);
|
|
|
int _DSA_EXPORT dsa_get_status_from_drive(DSA_DEVICE *dev, DSA_STATUS *status, long timeout);
|
|
|
int _DSA_EXPORT dsa_grp_cancel_status_wait(DSA_DEVICE_GROUP *grp);
|
|
|
int _DSA_EXPORT dsa_query_minimum_sample_time(DSA_DEVICE *obj, double *time);
|
|
|
int _DSA_EXPORT dsa_query_sample_time(DSA_DEVICE *obj, double time, double *real_time);
|
|
|
int _DSA_EXPORT dsa_begin_sync_trans(void);
|
|
|
int _DSA_EXPORT dsa_rollback_sync_trans(void);
|
|
|
int _DSA_EXPORT dsa_commit_sync_trans(long timeout);
|
|
|
int _DSA_EXPORT dsa_begin_async_trans(void);
|
|
|
int _DSA_EXPORT dsa_rollback_async_trans(void);
|
|
|
int _DSA_EXPORT dsa_commit_async_trans(DSA_DEVICE_BASE *grp, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_trans_level(int *level);
|
|
|
int _DSA_EXPORT dsa_get_x_info(DSA_DEVICE *dev, DSA_X_INFO *x_info);
|
|
|
int _DSA_EXPORT dsa_create_acquisition(DSA_ACQUISITION **acq, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_destroy_acquisition(DSA_ACQUISITION **acq);
|
|
|
bool _DSA_EXPORT dsa_is_valid_acquisition(DSA_ACQUISITION *acq);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trace(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int trace_idx, int typ, int idx, int sidx);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int trig_mode, int trig_trace_idx, double trig_level, int trig_level_conv);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_immediate_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_begin_of_movement_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int ipol_grp, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_end_of_movement_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int ipol_grp, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_position_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, double position, int conv, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_position_int64_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, eint64 inc_position, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trace_idx_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int trace_idx, double value, int conv, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trace_idx_int32_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int trace_idx, int value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trace_idx_int64_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int trace_idx, eint64 inc_value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trace_idx_float32_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int trace_idx, float inc_value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_trace_idx_float64_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int trace_idx, double inc_value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_register_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int typ, int idx, int sidx, double value, int conv, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_register_int32_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int typ, int idx, int sidx, int inc_value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_register_int64_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int typ, int idx, int sidx, eint64 inc_value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_register_float32_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int typ, int idx, int sidx, float inc_value, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_register_float64_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int edge, int typ, int idx, int sidx, double inc_value, double delay);
|
|
|
|
|
|
int _DSA_EXPORT dsa_acquisition_config_int32_bit_field_state_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int typ, int idx, int sidx, dword low_state_mask, dword high_state_mask, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_int64_bit_field_state_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int typ, int idx, int sidx, eint64 low_state_mask, eint64 high_state_mask, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_int32_bit_field_change_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int typ, int idx, int sidx, dword rising_edge_mask, dword falling_edge_mask, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_int64_bit_field_change_trigger(DSA_ACQUISITION *acq, DSA_DEVICE_BASE *dev, int typ, int idx, int sidx, eint64 rising_edge_mask, eint64 falling_edge_mask, double delay);
|
|
|
int _DSA_EXPORT dsa_acquisition_config_frequency (DSA_ACQUISITION *acq, int nb_points, double total_time, int synchro_mode, int upload_mode);
|
|
|
int _DSA_EXPORT dsa_acquisition_get_real_total_time(DSA_ACQUISITION *acq, double *real_total_time);
|
|
|
int _DSA_EXPORT dsa_acquisition_get_trace_real_nb_points(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int *real_nb_points);
|
|
|
int _DSA_EXPORT dsa_acquisition_upload_trace(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int table_size, double times[], double traces[], int conv);
|
|
|
int _DSA_EXPORT dsa_acquisition_upload_inctrace(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int table_size, double times[], int traces[]);
|
|
|
int _DSA_EXPORT dsa_acquisition_upload_int32_trace(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int table_size, double times[], int traces[]);
|
|
|
int _DSA_EXPORT dsa_acquisition_upload_int64_trace(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int table_size, double times[], eint64 traces[]);
|
|
|
int _DSA_EXPORT dsa_acquisition_upload_float32_trace(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int table_size, double times[], float traces[]);
|
|
|
int _DSA_EXPORT dsa_acquisition_upload_float64_trace(DSA_ACQUISITION *acq, DSA_DEVICE *dev, int trace_idx, int table_size, double times[], double traces[]);
|
|
|
int _DSA_EXPORT dsa_acquisition_stop_acquire(DSA_ACQUISITION *acq);
|
|
|
int _DSA_EXPORT dsa_acquisition_reserve(DSA_ACQUISITION *acq);
|
|
|
int _DSA_EXPORT dsa_acquisition_unreserve(DSA_ACQUISITION *acq);
|
|
|
int _DSA_EXPORT dsa_acquisition_set_name(DSA_ACQUISITION *acq, char *name);
|
|
|
int _DSA_EXPORT dsa_acquisition_unreserve_all(char *name);
|
|
|
int _DSA_EXPORT dsa_acquisition_is_reserved(DSA_ACQUISITION *acq, bool *reserved);
|
|
|
int _DSA_EXPORT dsa_acquisition_get_time_limits(DSA_ACQUISITION *acq, double *start_time, double *end_time);
|
|
|
int _DSA_EXPORT dsa_start_upload_trace_s(DSA_DEVICE *dev, int trace_typ, int trace_idx, int start_idx, int end_idx, int step_idx, bool fast, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_upload_sequence_s(DSA_DEVICE *dev, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_upload_register_s(DSA_DEVICE *dev, int typ, int start_idx, int end_idx, int sidx, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_download_sequence_s(DSA_DEVICE_BASE *grp, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_download_register_s(DSA_DEVICE_BASE *grp, int typ, int start_idx, int end_idx, int sidx, long timeout);
|
|
|
int _DSA_EXPORT dsa_download_data_s(DSA_DEVICE_BASE *grp, const void *data, size_t size, int timeout);
|
|
|
int _DSA_EXPORT dsa_upload_data_s(DSA_DEVICE *dev, void *data, size_t size, int timeout);
|
|
|
int _DSA_EXPORT dsa_download_compiled_sequence_file (DSA_DEVICE_BASE *dwn_grp, char* filename);
|
|
|
int _DSA_EXPORT dsa_set_sequence_version(DSA_DEVICE_BASE *dwn_grp, char *filename);
|
|
|
|
|
|
int _DSA_EXPORT dsa_get_nb_available_slots_s(DSA_DEVICE *obj, int *nb_free_slots, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_nb_available_slots_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_32bit_rtv0_slot(DSA_DSMAX *dsm, DSA_RTV_SLOT **slot);
|
|
|
int _DSA_EXPORT dsa_get_32bit_rtv1_slot(DSA_DSMAX *dsm, DSA_RTV_SLOT **slot, int sl);
|
|
|
int _DSA_EXPORT dsa_free_32bit_rtv_slot(DSA_RTV_SLOT **slot);
|
|
|
int _DSA_EXPORT dsa_get_64bit_rtv0_slot(DSA_DSMAX *dsm, DSA_RTV_SLOT **slot);
|
|
|
int _DSA_EXPORT dsa_get_64bit_rtv1_slot(DSA_DSMAX *dsm, DSA_RTV_SLOT **slot, int lsl, int msl);
|
|
|
int _DSA_EXPORT dsa_free_64bit_rtv_slot(DSA_RTV_SLOT **slot);
|
|
|
int _DSA_EXPORT dsa_assign_slot_to_register_s(DSA_DEVICE_BASE *grp, DSA_RTV_SLOT *slot, int typ, int idx, int sidx, int timeout);
|
|
|
int _DSA_EXPORT dsa_assign_slot_to_register_a(DSA_DEVICE_BASE *grp, DSA_RTV_SLOT *slot, int typ, int idx, int sidx, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_unassign_slot_to_register_s(DSA_DEVICE_BASE *grp, DSA_RTV_SLOT *slot, int typ, int idx, int sidx, int timeout);
|
|
|
int _DSA_EXPORT dsa_unassign_slot_to_register_a(DSA_DEVICE_BASE *grp, DSA_RTV_SLOT *slot, int typ, int idx, int sidx, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_assign_register_to_slot_s(DSA_DEVICE *dev, int typ, int idx, int sidx, DSA_RTV_SLOT *slot, int timeout);
|
|
|
int _DSA_EXPORT dsa_assign_register_to_slot_a(DSA_DEVICE *dev, int typ, int idx, int sidx, DSA_RTV_SLOT *slot, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_unassign_register_to_slot_s(DSA_DEVICE *dev, int typ, int idx, int sidx, DSA_RTV_SLOT *slot, int timeout);
|
|
|
int _DSA_EXPORT dsa_unassign_register_to_slot_a(DSA_DEVICE *dev, int typ, int idx, int sidx, DSA_RTV_SLOT *slot, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_read_32bit_rtv_slot(DSA_RTV_SLOT *slot, dword *value);
|
|
|
int _DSA_EXPORT dsa_write_32bit_rtv_slot(DSA_RTV_SLOT *slot, dword value);
|
|
|
int _DSA_EXPORT dsa_read_64bit_rtv_slot(DSA_RTV_SLOT *slot, dword *lvalue, dword *mvalue);
|
|
|
int _DSA_EXPORT dsa_write_64bit_rtv_slot(DSA_RTV_SLOT *slot, dword lvalue, dword mvalue);
|
|
|
bool _DSA_EXPORT dsa_is_valid_rtv_slot(DSA_RTV_SLOT *slot);
|
|
|
bool _DSA_EXPORT dsa_is_32bit_rtv_slot(DSA_RTV_SLOT *slot);
|
|
|
bool _DSA_EXPORT dsa_is_64bit_rtv_slot(DSA_RTV_SLOT *slot);
|
|
|
int _DSA_EXPORT dsa_get_32bit_rtv_slot_nr(DSA_RTV_SLOT *slot, int *lsl);
|
|
|
int _DSA_EXPORT dsa_get_64bit_rtv_slot_nr(DSA_RTV_SLOT *slot, int *lsl, int *msl);
|
|
|
|
|
|
int _DSA_EXPORT dsa_create_rtv_read(DSA_DEVICE *dev, int reg_typ, int reg_idx, int reg_sidx, DSA_RTV_DATA **rtv_data);
|
|
|
int _DSA_EXPORT dsa_create_rtv_write(DSA_DEVICE *dev, int inc_typ, DSA_RTV_DATA **rtv_data);
|
|
|
int _DSA_EXPORT dsa_destroy_rtv(DSA_RTV_DATA **rtv_data);
|
|
|
int _DSA_EXPORT dsa_read_rtv_int32(DSA_RTV_DATA *rtv_data, int *value);
|
|
|
int _DSA_EXPORT dsa_read_rtv_int64(DSA_RTV_DATA *rtv_data, eint64 *value);
|
|
|
int _DSA_EXPORT dsa_read_rtv_float32(DSA_RTV_DATA *rtv_data, float *value);
|
|
|
int _DSA_EXPORT dsa_read_rtv_float64(DSA_RTV_DATA *rtv_data, double *value);
|
|
|
int _DSA_EXPORT dsa_write_rtv_int32(DSA_RTV_DATA *rtv_data, int value);
|
|
|
int _DSA_EXPORT dsa_write_rtv_int64(DSA_RTV_DATA *rtv_data, eint64 value);
|
|
|
int _DSA_EXPORT dsa_write_rtv_float32(DSA_RTV_DATA *rtv_data, float value);
|
|
|
int _DSA_EXPORT dsa_write_rtv_float64(DSA_RTV_DATA *rtv_data, double value);
|
|
|
bool _DSA_EXPORT dsa_is_valid_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
bool _DSA_EXPORT dsa_is_read_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
bool _DSA_EXPORT dsa_is_write_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
bool _DSA_EXPORT dsa_is_int32_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
bool _DSA_EXPORT dsa_is_int64_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
bool _DSA_EXPORT dsa_is_float32_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
bool _DSA_EXPORT dsa_is_float64_rtv(DSA_RTV_DATA *rtv_data);
|
|
|
int _DSA_EXPORT dsa_get_register_typ_idx_sidx_rtv(DSA_RTV_DATA *rtv_data, int *reg_typ, int *reg_idx, int *reg_sidx);
|
|
|
int _DSA_EXPORT dsa_get_rtv_slot_of_rtv(DSA_RTV_DATA *rtv_data, DSA_RTV_SLOT **slot);
|
|
|
int _DSA_EXPORT dsa_start_rtv_handler(DSA_DSMAX *ultimet, int nr, int rate, DSA_RTV_HANDLER handler, int nb_read, DSA_RTV_DATA *read_rtv[], int nb_write, DSA_RTV_DATA *write_rtv[], void *user);
|
|
|
int _DSA_EXPORT dsa_stop_rtv_handler(DSA_DSMAX *ultimet, int nr);
|
|
|
int _DSA_EXPORT dsa_get_rtv_handler_activity(DSA_DSMAX *ultimet, int nr, bool *active);
|
|
|
int _DSA_EXPORT dsa_set_watchdog(DSA_DSMAX *ultimet, double ms);
|
|
|
int _DSA_EXPORT dsa_stage_mapping_download(DSA_DRIVE_GROUP *grp, const char *file_name);
|
|
|
int _DSA_EXPORT dsa_stage_mapping_upload(DSA_DRIVE_GROUP *grp, const char *file_name);
|
|
|
int _DSA_EXPORT dsa_stage_mapping_activate(DSA_DRIVE_BASE *grp);
|
|
|
int _DSA_EXPORT dsa_stage_mapping_deactivate(DSA_DRIVE_BASE *grp);
|
|
|
int _DSA_EXPORT dsa_stage_mapping_get_activation(DSA_DRIVE_BASE *grp, bool *active);
|
|
|
int _DSA_EXPORT dsa_scale_mapping_download(DSA_DRIVE *drv, const char *file_name, dword pre_processing_mode);
|
|
|
int _DSA_EXPORT dsa_scale_mapping_activate(DSA_DRIVE *drv, dword mode);
|
|
|
int _DSA_EXPORT dsa_scale_mapping_deactivate(DSA_DRIVE *drv);
|
|
|
int _DSA_EXPORT dsa_scale_mapping_get_activation(DSA_DRIVE *drv, bool *active);
|
|
|
int _DSA_EXPORT dsa_ipol_get_ipol_grp(DSA_IPOL_GROUP *igrp, int *ipol_grp);
|
|
|
|
|
|
#ifdef QNX4
|
|
|
#pragma off(unreferenced)
|
|
|
#endif
|
|
|
|
|
|
static DSA_STATUS global_status;
|
|
|
#define dsa_init_status() (memset(&global_status, 0, sizeof(DSA_STATUS)), global_status.size = sizeof(DSA_STATUS), global_status)
|
|
|
|
|
|
static DSA_INFO global_info;
|
|
|
#define dsa_init_info() (memset(&global_info, 0, sizeof(DSA_INFO)), global_info.size = sizeof(DSA_INFO), global_info)
|
|
|
|
|
|
static DSA_X_INFO global_x_info;
|
|
|
#define dsa_init_x_info() (memset(&global_x_info, 0, sizeof(DSA_X_INFO)), global_x_info.size = sizeof(DSA_X_INFO), global_x_info)
|
|
|
|
|
|
static DSA_VECTOR global_vector;
|
|
|
#define dsa_init_vector() (memset(&global_vector, 0, sizeof(DSA_VECTOR)), global_vector.size = sizeof(DSA_VECTOR), global_vector)
|
|
|
|
|
|
static DSA_VECTOR_TYP global_vector_typ;
|
|
|
#define dsa_init_vector_typ() (memset(&global_vector_typ, 0, sizeof(DSA_VECTOR_TYP)), global_vector_typ.size = sizeof(DSA_VECTOR_TYP), global_vector_typ)
|
|
|
|
|
|
static DSA_RTM global_rtm;
|
|
|
#define dsa_init_rtm() (memset(&global_rtm, 0, sizeof(DSA_RTM)), global_rtm.size = sizeof(DSA_RTM), global_rtm)
|
|
|
|
|
|
#ifdef QNX4
|
|
|
#pragma on(unreferenced)
|
|
|
#endif
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* very special functions - do not use for normal applications
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_S
|
|
|
int _DSA_EXPORT dsa_quick_register_request_s(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_quick_register_int32_request_s(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_quick_register_int64_request_s(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, eint64 *val1, int typ2, unsigned idx2, int sidx2, eint64 *val2, dword *rx_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_quick_register_float32_request_s(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, float *val1, int typ2, unsigned idx2, int sidx2, float *val2, dword *rx_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_quick_register_float64_request_s(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, double *val1, int typ2, unsigned idx2, int sidx2, double *val2, dword *rx_time, long timeout);
|
|
|
int _DSA_EXPORT dsa_quick_address_request_s(DSA_DEVICE *dev, dword addr1, long *val1, dword addr2, long *val2, long timeout);
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
|
|
|
#ifdef DSA_IMPL_A
|
|
|
int _DSA_EXPORT dsa_quick_register_request_a(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, DSA_2INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_quick_register_int32_request_a(DSA_DEVICE *dev, int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, DSA_2INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_quick_address_request_a(DSA_DEVICE *dev, dword addr1, long *val1, dword addr2, long *val2, DSA_2INT_HANDLER handler, void *param);
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* commands - synchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_S
|
|
|
int _DSA_EXPORT dsa_reset_error_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_step_motion_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_sequence_s(DSA_DEVICE_BASE *obj, int label, long timeout);
|
|
|
int _DSA_EXPORT dsa_execute_sequence_in_thread_s(DSA_DEVICE_BASE *obj, int label, int thread_nr, long timeout);
|
|
|
int _DSA_EXPORT dsa_stop_sequence_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_stop_sequence_in_thread_s(DSA_DEVICE_BASE *obj, int thread_nr, long timeout);
|
|
|
int _DSA_EXPORT dsa_edit_sequence_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_exit_sequence_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_can_command_1_s(DSA_DRIVE_BASE *obj, dword val1, dword val2, long timeout);
|
|
|
int _DSA_EXPORT dsa_can_command_2_s(DSA_DRIVE_BASE *obj, dword val1, dword val2, long timeout);
|
|
|
int _DSA_EXPORT dsa_save_parameters_s(DSA_DEVICE_BASE *obj, int what, long timeout);
|
|
|
int _DSA_EXPORT dsa_load_parameters_s(DSA_DEVICE_BASE *obj, int what, long timeout);
|
|
|
int _DSA_EXPORT dsa_default_parameters_s(DSA_DEVICE_BASE *obj, int what, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_movement_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_position_s(DSA_DEVICE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_time_s(DSA_DEVICE_BASE *obj, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_window_s(DSA_DEVICE_BASE *obj, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_bit_set_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_bit_clear_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_greater_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_lower_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_window_user_channel_s(DSA_DEVICE_BASE *obj, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_movement_user_channel_s(DSA_DEVICE_BASE *obj, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_time_user_channel_s(DSA_DEVICE_BASE *obj, double time, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_position_user_channel_s(DSA_DEVICE_BASE *obj, double pos, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_greater_user_channel_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_lower_user_channel_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_bit_set_user_channel_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, int channel, long timeout);
|
|
|
int _DSA_EXPORT dsa_wait_bit_clear_user_channel_s(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, int channel, long timeout);
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* commands - asynchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_A
|
|
|
int _DSA_EXPORT dsa_reset_error_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_step_motion_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_sequence_a(DSA_DEVICE_BASE *obj, int label, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_execute_sequence_in_thread_a(DSA_DEVICE_BASE *obj, int label, int thread_nr, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_stop_sequence_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_stop_sequence_in_thread_a(DSA_DEVICE_BASE *obj, int thread_nr, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_edit_sequence_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_exit_sequence_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_can_command_1_a(DSA_DRIVE_BASE *obj, dword val1, dword val2, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_can_command_2_a(DSA_DRIVE_BASE *obj, dword val1, dword val2, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_save_parameters_a(DSA_DEVICE_BASE *obj, int what, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_load_parameters_a(DSA_DEVICE_BASE *obj, int what, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_default_parameters_a(DSA_DEVICE_BASE *obj, int what, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_movement_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_position_a(DSA_DEVICE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_time_a(DSA_DEVICE_BASE *obj, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_window_a(DSA_DEVICE_BASE *obj, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_bit_set_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_bit_clear_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_greater_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_lower_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_window_user_channel_a(DSA_DEVICE_BASE *obj, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_movement_user_channel_a(DSA_DEVICE_BASE *obj, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_time_user_channel_a(DSA_DEVICE_BASE *obj, double time, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_position_user_channel_a(DSA_DEVICE_BASE *obj, double pos, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_greater_user_channel_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_sgn_register_lower_user_channel_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, double value, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_bit_set_user_channel_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, int channel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_wait_bit_clear_user_channel_a(DSA_DEVICE_BASE *obj, int typ, int idx, int sidx, dword mask, int channel, DSA_HANDLER handler, void *param);
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* register getter - synchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_S
|
|
|
int _DSA_EXPORT dsa_get_pl_proportional_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_speed_feedback_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_force_feedback_gain_1_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_integrator_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_anti_windup_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_integrator_limitation_s(DSA_DRIVE *obj, double *limit, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_integrator_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_speed_filter_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_output_filter_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_input_filter_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ttl_special_filter_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_force_feedback_gain_2_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_speed_feedfwd_gain_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pl_acc_feedforward_gain_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_phase_advance_factor_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_apr_input_filter_s(DSA_DRIVE *obj, double *time, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_phase_advance_shift_s(DSA_DRIVE *obj, double *shift, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_min_position_range_limit_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_max_position_range_limit_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_max_profile_velocity_s(DSA_DRIVE *obj, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_max_acceleration_s(DSA_DRIVE *obj, double *acc, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_following_error_window_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_velocity_error_limit_s(DSA_DRIVE *obj, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_switch_limit_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_enable_input_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_min_soft_position_limit_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_max_soft_position_limit_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_profile_limit_mode_s(DSA_DRIVE *obj, dword *flags, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_io_error_event_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_position_window_time_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_position_window_s(DSA_DRIVE *obj, double *win, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_method_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_zero_speed_s(DSA_DRIVE *obj, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_acceleration_s(DSA_DRIVE *obj, double *acc, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_following_limit_s(DSA_DRIVE *obj, double *win, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_current_limit_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_home_offset_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_fixed_mvt_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_switch_mvt_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_index_mvt_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_fine_tuning_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_homing_fine_tuning_value_s(DSA_DRIVE *obj, double *phase, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_motor_phase_correction_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_software_current_limit_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_control_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_display_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_inversion_s(DSA_DRIVE *obj, double *invert, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_pdr_step_value_s(DSA_DRIVE *obj, double *step, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_1_offset_s(DSA_DRIVE *obj, double *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_2_offset_s(DSA_DRIVE *obj, double *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_1_factor_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_2_factor_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_3_offset_s(DSA_DRIVE *obj, double *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_index_distance_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_3_factor_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_proportional_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_integrator_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_output_filter_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_limit_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_i2t_current_limit_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_i2t_time_limit_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_regen_mode_s(DSA_DRIVE *obj, int *mode, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_mode_s(DSA_DRIVE *obj, int *typ, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_pulse_level_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_max_current_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_final_phase_s(DSA_DRIVE *obj, double *cal, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_time_s(DSA_DRIVE *obj, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_current_rate_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_phase_rate_s(DSA_DRIVE *obj, double *cal, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_init_initial_phase_s(DSA_DRIVE *obj, double *cal, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_fuse_checking_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_motor_temp_checking_s(DSA_DRIVE *obj, dword *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mon_source_type_s(DSA_DRIVE *obj, int sidx, int *typ, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mon_source_index_s(DSA_DRIVE *obj, int sidx, int *index, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mon_dest_index_s(DSA_DRIVE *obj, int sidx, int *index, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mon_offset_s(DSA_DRIVE *obj, int sidx, long *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mon_gain_s(DSA_DRIVE *obj, int sidx, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_offset_s(DSA_DRIVE *obj, int sidx, double *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_gain_s(DSA_DRIVE *obj, int sidx, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_syncro_input_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_syncro_input_value_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_syncro_output_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_syncro_output_value_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_syncro_start_timeout_s(DSA_DRIVE *obj, int *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_digital_output_s(DSA_DRIVE *obj, dword *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_digital_output_s(DSA_DRIVE *obj, dword *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_1_s(DSA_DRIVE *obj, double *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_2_s(DSA_DRIVE *obj, double *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_3_s(DSA_DRIVE *obj, double *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_4_s(DSA_DRIVE *obj, double *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_analog_output_s(DSA_DRIVE *obj, double *out, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_interrupt_mask_1_s(DSA_DRIVE *obj, int sidx, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_interrupt_mask_2_s(DSA_DRIVE *obj, int sidx, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_trigger_irq_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_trigger_io_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_trigger_map_offset_s(DSA_DRIVE *obj, int *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_trigger_map_size_s(DSA_DRIVE *obj, int *size, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_realtime_enabled_global_s(DSA_DRIVE *obj, int *enable, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_realtime_valid_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_realtime_enabled_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_realtime_pending_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ebl_baudrate_s(DSA_DRIVE *obj, long *baud, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_indirect_axis_number_s(DSA_DRIVE *obj, int *axis, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_indirect_register_idx_s(DSA_DRIVE *obj, int *idx, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_indirect_register_sidx_s(DSA_DRIVE *obj, int *sidx, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_concatenated_mvt_s(DSA_DRIVE *obj, int *concat, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_profile_type_s(DSA_DRIVE *obj, int sidx, int *typ, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mvt_lkt_number_s(DSA_DRIVE *obj, int sidx, int *number, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_mvt_lkt_time_s(DSA_DRIVE *obj, int sidx, double *time, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_came_value_s(DSA_DRIVE *obj, double *factor, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_brake_deceleration_s(DSA_DRIVE *obj, double *dec, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_target_position_s(DSA_DRIVE *obj, int sidx, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_profile_velocity_s(DSA_DRIVE *obj, int sidx, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_profile_acceleration_s(DSA_DRIVE *obj, int sidx, double *acc, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_jerk_time_s(DSA_DRIVE *obj, int sidx, double *tim, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_profile_deceleration_s(DSA_DRIVE *obj, int sidx, double *dec, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_end_velocity_s(DSA_DRIVE *obj, int sidx, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_source_type_s(DSA_DRIVE *obj, int *typ, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_source_index_s(DSA_DRIVE *obj, int *index, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_shift_factor_s(DSA_DRIVE *obj, int *shift, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_offset_s(DSA_DRIVE *obj, long *offset, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_gain_s(DSA_DRIVE *obj, double *gain, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_motor_kt_factor_s(DSA_DRIVE *obj, double *kt, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_position_ctrl_error_s(DSA_DRIVE *obj, double *err, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_position_max_error_s(DSA_DRIVE *obj, double *err, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_position_demand_value_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_position_actual_value_s(DSA_DRIVE *obj, double *pos, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_velocity_demand_value_s(DSA_DRIVE *obj, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_velocity_actual_value_s(DSA_DRIVE *obj, double *vel, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_acc_demand_value_s(DSA_DRIVE *obj, double *acc, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_acc_actual_value_s(DSA_DRIVE *obj, double *acc, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ref_demand_value_s(DSA_DRIVE *obj, double *ref, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_control_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_phase_1_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_phase_2_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_phase_3_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_lkt_phase_1_s(DSA_DRIVE *obj, double *lkt, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_lkt_phase_2_s(DSA_DRIVE *obj, double *lkt, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_lkt_phase_3_s(DSA_DRIVE *obj, double *lkt, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_demand_value_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_actual_value_s(DSA_DRIVE *obj, double *cur, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_sine_signal_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_cosine_signal_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_index_signal_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_1_signal_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_2_signal_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_3_signal_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_dig_signal_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_digital_input_s(DSA_DRIVE *obj, dword *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_analog_input_s(DSA_DRIVE *obj, double *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_digital_input_s(DSA_DRIVE *obj, dword *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_1_s(DSA_DRIVE *obj, double *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_2_s(DSA_DRIVE *obj, double *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_3_s(DSA_DRIVE *obj, double *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_4_s(DSA_DRIVE *obj, double *inp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_status_1_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_status_2_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_cl_i2t_value_s(DSA_DRIVE *obj, double *val, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_axis_number_s(DSA_DRIVE *obj, int *num, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_daisy_chain_number_s(DSA_DRIVE *obj, int *num, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_temperature_s(DSA_DRIVE *obj, double *temp, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_mask_value_s(DSA_DRIVE *obj, dword *str, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_display_s(DSA_DRIVE *obj, int sidx, dword *str, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_sequence_line_s(DSA_DRIVE *obj, long *line, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_drive_fuse_status_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_irq_drive_status_1_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_irq_drive_status_2_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ack_drive_status_1_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_ack_drive_status_2_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_irq_pending_axis_mask_s(DSA_DRIVE *obj, dword *mask, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_can_feedback_1_s(DSA_DRIVE *obj, dword *val1, int kind, long timeout);
|
|
|
int _DSA_EXPORT dsa_get_can_feedback_2_s(DSA_DRIVE *obj, dword *val1, int kind, long timeout);
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* register setter - synchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_S
|
|
|
int _DSA_EXPORT dsa_set_pl_proportional_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_speed_feedback_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_force_feedback_gain_1_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_integrator_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_anti_windup_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_integrator_limitation_s(DSA_DRIVE_BASE *obj, double limit, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_integrator_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_speed_filter_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_output_filter_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_input_filter_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ttl_special_filter_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_force_feedback_gain_2_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_speed_feedfwd_gain_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pl_acc_feedforward_gain_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_phase_advance_factor_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_apr_input_filter_s(DSA_DRIVE_BASE *obj, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_phase_advance_shift_s(DSA_DRIVE_BASE *obj, double shift, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_min_position_range_limit_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_max_position_range_limit_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_max_profile_velocity_s(DSA_DRIVE_BASE *obj, double vel, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_max_acceleration_s(DSA_DRIVE_BASE *obj, double acc, long timeout);
|
|
|
int _DSA_EXPORT dsa_start_movement_s(DSA_DRIVE_BASE *grp, double *targets, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_following_error_window_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_velocity_error_limit_s(DSA_DRIVE_BASE *obj, double vel, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_switch_limit_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_enable_input_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_min_soft_position_limit_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_max_soft_position_limit_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_profile_limit_mode_s(DSA_DRIVE_BASE *obj, dword flags, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_io_error_event_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_position_window_time_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_position_window_s(DSA_DRIVE_BASE *obj, double win, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_method_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_zero_speed_s(DSA_DRIVE_BASE *obj, double vel, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_acceleration_s(DSA_DRIVE_BASE *obj, double acc, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_following_limit_s(DSA_DRIVE_BASE *obj, double win, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_current_limit_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_home_offset_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_fixed_mvt_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_switch_mvt_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_index_mvt_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_fine_tuning_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_homing_fine_tuning_value_s(DSA_DRIVE_BASE *obj, double phase, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_motor_phase_correction_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_software_current_limit_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_drive_control_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_display_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_inversion_s(DSA_DRIVE_BASE *obj, double invert, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_pdr_step_value_s(DSA_DRIVE_BASE *obj, double step, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_1_offset_s(DSA_DRIVE_BASE *obj, double offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_2_offset_s(DSA_DRIVE_BASE *obj, double offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_1_factor_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_2_factor_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_3_offset_s(DSA_DRIVE_BASE *obj, double offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_index_distance_s(DSA_DRIVE_BASE *obj, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_3_factor_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_proportional_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_integrator_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_output_filter_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_current_limit_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_i2t_current_limit_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_i2t_time_limit_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_cl_regen_mode_s(DSA_DRIVE_BASE *obj, int mode, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_mode_s(DSA_DRIVE_BASE *obj, int typ, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_pulse_level_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_max_current_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_final_phase_s(DSA_DRIVE_BASE *obj, double cal, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_time_s(DSA_DRIVE_BASE *obj, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_current_rate_s(DSA_DRIVE_BASE *obj, double cur, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_phase_rate_s(DSA_DRIVE_BASE *obj, double cal, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_init_initial_phase_s(DSA_DRIVE_BASE *obj, double cal, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_drive_fuse_checking_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_motor_temp_checking_s(DSA_DRIVE_BASE *obj, dword val, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mon_source_type_s(DSA_DRIVE_BASE *obj, int sidx, int typ, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mon_source_index_s(DSA_DRIVE_BASE *obj, int sidx, int index, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mon_dest_index_s(DSA_DRIVE_BASE *obj, int sidx, int index, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mon_offset_s(DSA_DRIVE_BASE *obj, int sidx, long offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mon_gain_s(DSA_DRIVE_BASE *obj, int sidx, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_offset_s(DSA_DRIVE_BASE *obj, int sidx, double offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_gain_s(DSA_DRIVE_BASE *obj, int sidx, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_syncro_input_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_syncro_input_value_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_syncro_output_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_syncro_output_value_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_syncro_start_timeout_s(DSA_DRIVE_BASE *obj, int tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_digital_output_s(DSA_DRIVE_BASE *obj, dword out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_digital_output_s(DSA_DRIVE_BASE *obj, dword out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_1_s(DSA_DRIVE_BASE *obj, double out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_2_s(DSA_DRIVE_BASE *obj, double out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_3_s(DSA_DRIVE_BASE *obj, double out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_4_s(DSA_DRIVE_BASE *obj, double out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_analog_output_s(DSA_DRIVE_BASE *obj, double out, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_interrupt_mask_1_s(DSA_DRIVE_BASE *obj, int sidx, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_interrupt_mask_2_s(DSA_DRIVE_BASE *obj, int sidx, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trigger_irq_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trigger_io_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trigger_map_offset_s(DSA_DRIVE_BASE *obj, int offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_trigger_map_size_s(DSA_DRIVE_BASE *obj, int size, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_realtime_enabled_global_s(DSA_DRIVE_BASE *obj, int enable, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_realtime_valid_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_realtime_enabled_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_realtime_pending_mask_s(DSA_DRIVE_BASE *obj, dword mask, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ebl_baudrate_s(DSA_DRIVE_BASE *obj, long baud, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_indirect_axis_number_s(DSA_DRIVE_BASE *obj, int axis, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_indirect_register_idx_s(DSA_DRIVE_BASE *obj, int idx, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_indirect_register_sidx_s(DSA_DRIVE_BASE *obj, int sidx, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_concatenated_mvt_s(DSA_DRIVE_BASE *obj, int concat, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_profile_type_s(DSA_DRIVE_BASE *obj, int sidx, int typ, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mvt_lkt_number_s(DSA_DRIVE_BASE *obj, int sidx, int number, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_mvt_lkt_time_s(DSA_DRIVE_BASE *obj, int sidx, double time, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_came_value_s(DSA_DRIVE_BASE *obj, double factor, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_brake_deceleration_s(DSA_DRIVE_BASE *obj, double dec, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_target_position_s(DSA_DRIVE_BASE *obj, int sidx, double pos, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_profile_velocity_s(DSA_DRIVE_BASE *obj, int sidx, double vel, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_profile_acceleration_s(DSA_DRIVE_BASE *obj, int sidx, double acc, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_jerk_time_s(DSA_DRIVE_BASE *obj, int sidx, double tim, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_profile_deceleration_s(DSA_DRIVE_BASE *obj, int sidx, double dec, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_end_velocity_s(DSA_DRIVE_BASE *obj, int sidx, double vel, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_source_type_s(DSA_DRIVE_BASE *obj, int typ, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_source_index_s(DSA_DRIVE_BASE *obj, int index, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_shift_factor_s(DSA_DRIVE_BASE *obj, int shift, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_offset_s(DSA_DRIVE_BASE *obj, long offset, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_gain_s(DSA_DRIVE_BASE *obj, double gain, long timeout);
|
|
|
int _DSA_EXPORT dsa_set_motor_kt_factor_s(DSA_DRIVE_BASE *obj, double kt, long timeout);
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* register getter - asynchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_A
|
|
|
int _DSA_EXPORT dsa_get_pl_proportional_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_speed_feedback_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_force_feedback_gain_1_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_integrator_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_anti_windup_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_integrator_limitation_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_integrator_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_speed_filter_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_output_filter_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_input_filter_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ttl_special_filter_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_force_feedback_gain_2_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_speed_feedfwd_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pl_acc_feedforward_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_phase_advance_factor_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_apr_input_filter_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_phase_advance_shift_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_min_position_range_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_max_position_range_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_max_profile_velocity_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_max_acceleration_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_following_error_window_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_velocity_error_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_switch_limit_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_enable_input_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_min_soft_position_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_max_soft_position_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_profile_limit_mode_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_io_error_event_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_position_window_time_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_position_window_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_method_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_zero_speed_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_acceleration_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_following_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_current_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_home_offset_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_fixed_mvt_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_switch_mvt_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_index_mvt_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_fine_tuning_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_homing_fine_tuning_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_motor_phase_correction_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_software_current_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_control_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_display_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_inversion_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_pdr_step_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_1_offset_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_2_offset_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_1_factor_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_2_factor_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_3_offset_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_index_distance_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_phase_3_factor_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_proportional_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_integrator_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_output_filter_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_i2t_current_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_i2t_time_limit_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_regen_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_mode_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_pulse_level_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_max_current_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_final_phase_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_time_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_current_rate_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_phase_rate_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_init_initial_phase_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_fuse_checking_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_motor_temp_checking_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mon_source_type_a(DSA_DRIVE *obj, int sidx, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mon_source_index_a(DSA_DRIVE *obj, int sidx, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mon_dest_index_a(DSA_DRIVE *obj, int sidx, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mon_offset_a(DSA_DRIVE *obj, int sidx, int kind, DSA_LONG_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mon_gain_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_offset_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_gain_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_syncro_input_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_syncro_input_value_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_syncro_output_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_syncro_output_value_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_syncro_start_timeout_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_digital_output_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_digital_output_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_1_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_2_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_3_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_output_4_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_analog_output_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_interrupt_mask_1_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_interrupt_mask_2_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_trigger_irq_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_trigger_io_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_trigger_map_offset_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_trigger_map_size_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_realtime_enabled_global_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_realtime_valid_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_realtime_enabled_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_realtime_pending_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ebl_baudrate_a(DSA_DRIVE *obj, int kind, DSA_LONG_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_indirect_axis_number_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_indirect_register_idx_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_indirect_register_sidx_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_concatenated_mvt_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_profile_type_a(DSA_DRIVE *obj, int sidx, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mvt_lkt_number_a(DSA_DRIVE *obj, int sidx, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_mvt_lkt_time_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_came_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_brake_deceleration_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_target_position_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_profile_velocity_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_profile_acceleration_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_jerk_time_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_profile_deceleration_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_end_velocity_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_source_type_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_source_index_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_shift_factor_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_offset_a(DSA_DRIVE *obj, int kind, DSA_LONG_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ctrl_gain_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_motor_kt_factor_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_position_ctrl_error_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_position_max_error_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_position_demand_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_position_actual_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_velocity_demand_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_velocity_actual_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_acc_demand_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_acc_actual_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ref_demand_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_control_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_phase_1_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_phase_2_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_current_phase_3_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_lkt_phase_1_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_lkt_phase_2_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_lkt_phase_3_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_demand_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_actual_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_sine_signal_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_cosine_signal_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_index_signal_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_1_signal_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_2_signal_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_3_signal_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_encoder_hall_dig_signal_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_digital_input_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_analog_input_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_digital_input_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_1_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_2_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_3_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_x_analog_input_4_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_status_1_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_status_2_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_cl_i2t_value_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_axis_number_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_daisy_chain_number_a(DSA_DRIVE *obj, int kind, DSA_INT_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_temperature_a(DSA_DRIVE *obj, int kind, DSA_DOUBLE_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_mask_value_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_display_a(DSA_DRIVE *obj, int sidx, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_sequence_line_a(DSA_DRIVE *obj, int kind, DSA_LONG_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_drive_fuse_status_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_irq_drive_status_1_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_irq_drive_status_2_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ack_drive_status_1_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_ack_drive_status_2_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_irq_pending_axis_mask_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_can_feedback_1_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_get_can_feedback_2_a(DSA_DRIVE *obj, int kind, DSA_DWORD_HANDLER handler, void *param);
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* register setter - asynchronous
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#ifdef DSA_IMPL_A
|
|
|
int _DSA_EXPORT dsa_set_pl_proportional_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_speed_feedback_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_force_feedback_gain_1_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_integrator_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_anti_windup_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_integrator_limitation_a(DSA_DRIVE_BASE *obj, double limit, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_integrator_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_speed_filter_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_output_filter_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_input_filter_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ttl_special_filter_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_force_feedback_gain_2_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_speed_feedfwd_gain_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pl_acc_feedforward_gain_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_phase_advance_factor_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_apr_input_filter_a(DSA_DRIVE_BASE *obj, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_phase_advance_shift_a(DSA_DRIVE_BASE *obj, double shift, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_min_position_range_limit_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_max_position_range_limit_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_max_profile_velocity_a(DSA_DRIVE_BASE *obj, double vel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_max_acceleration_a(DSA_DRIVE_BASE *obj, double acc, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_start_movement_a(DSA_DRIVE_BASE *grp, double *targets, DSA_HANDLER, void *param);
|
|
|
int _DSA_EXPORT dsa_set_following_error_window_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_velocity_error_limit_a(DSA_DRIVE_BASE *obj, double vel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_switch_limit_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_enable_input_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_min_soft_position_limit_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_max_soft_position_limit_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_profile_limit_mode_a(DSA_DRIVE_BASE *obj, dword flags, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_io_error_event_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_position_window_time_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_position_window_a(DSA_DRIVE_BASE *obj, double win, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_method_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_zero_speed_a(DSA_DRIVE_BASE *obj, double vel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_acceleration_a(DSA_DRIVE_BASE *obj, double acc, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_following_limit_a(DSA_DRIVE_BASE *obj, double win, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_current_limit_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_home_offset_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_fixed_mvt_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_switch_mvt_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_index_mvt_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_fine_tuning_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_homing_fine_tuning_value_a(DSA_DRIVE_BASE *obj, double phase, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_motor_phase_correction_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_software_current_limit_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_drive_control_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_display_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_inversion_a(DSA_DRIVE_BASE *obj, double invert, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_pdr_step_value_a(DSA_DRIVE_BASE *obj, double step, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_1_offset_a(DSA_DRIVE_BASE *obj, double offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_2_offset_a(DSA_DRIVE_BASE *obj, double offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_1_factor_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_2_factor_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_3_offset_a(DSA_DRIVE_BASE *obj, double offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_index_distance_a(DSA_DRIVE_BASE *obj, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_encoder_phase_3_factor_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_proportional_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_integrator_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_output_filter_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_current_limit_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_i2t_current_limit_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_i2t_time_limit_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_cl_regen_mode_a(DSA_DRIVE_BASE *obj, int mode, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_mode_a(DSA_DRIVE_BASE *obj, int typ, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_pulse_level_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_max_current_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_final_phase_a(DSA_DRIVE_BASE *obj, double cal, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_time_a(DSA_DRIVE_BASE *obj, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_current_rate_a(DSA_DRIVE_BASE *obj, double cur, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_phase_rate_a(DSA_DRIVE_BASE *obj, double cal, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_init_initial_phase_a(DSA_DRIVE_BASE *obj, double cal, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_drive_fuse_checking_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_motor_temp_checking_a(DSA_DRIVE_BASE *obj, dword val, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mon_source_type_a(DSA_DRIVE_BASE *obj, int sidx, int typ, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mon_source_index_a(DSA_DRIVE_BASE *obj, int sidx, int index, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mon_dest_index_a(DSA_DRIVE_BASE *obj, int sidx, int index, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mon_offset_a(DSA_DRIVE_BASE *obj, int sidx, long offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mon_gain_a(DSA_DRIVE_BASE *obj, int sidx, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_offset_a(DSA_DRIVE_BASE *obj, int sidx, double offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_gain_a(DSA_DRIVE_BASE *obj, int sidx, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_syncro_input_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_syncro_input_value_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_syncro_output_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_syncro_output_value_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_syncro_start_timeout_a(DSA_DRIVE_BASE *obj, int tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_digital_output_a(DSA_DRIVE_BASE *obj, dword out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_digital_output_a(DSA_DRIVE_BASE *obj, dword out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_1_a(DSA_DRIVE_BASE *obj, double out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_2_a(DSA_DRIVE_BASE *obj, double out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_3_a(DSA_DRIVE_BASE *obj, double out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_x_analog_output_4_a(DSA_DRIVE_BASE *obj, double out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_analog_output_a(DSA_DRIVE_BASE *obj, double out, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_interrupt_mask_1_a(DSA_DRIVE_BASE *obj, int sidx, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_interrupt_mask_2_a(DSA_DRIVE_BASE *obj, int sidx, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trigger_irq_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trigger_io_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trigger_map_offset_a(DSA_DRIVE_BASE *obj, int offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_trigger_map_size_a(DSA_DRIVE_BASE *obj, int size, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_realtime_enabled_global_a(DSA_DRIVE_BASE *obj, int enable, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_realtime_valid_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_realtime_enabled_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_realtime_pending_mask_a(DSA_DRIVE_BASE *obj, dword mask, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ebl_baudrate_a(DSA_DRIVE_BASE *obj, long baud, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_indirect_axis_number_a(DSA_DRIVE_BASE *obj, int axis, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_indirect_register_idx_a(DSA_DRIVE_BASE *obj, int idx, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_indirect_register_sidx_a(DSA_DRIVE_BASE *obj, int sidx, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_concatenated_mvt_a(DSA_DRIVE_BASE *obj, int concat, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_profile_type_a(DSA_DRIVE_BASE *obj, int sidx, int typ, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mvt_lkt_number_a(DSA_DRIVE_BASE *obj, int sidx, int number, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_mvt_lkt_time_a(DSA_DRIVE_BASE *obj, int sidx, double time, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_came_value_a(DSA_DRIVE_BASE *obj, double factor, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_brake_deceleration_a(DSA_DRIVE_BASE *obj, double dec, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_target_position_a(DSA_DRIVE_BASE *obj, int sidx, double pos, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_profile_velocity_a(DSA_DRIVE_BASE *obj, int sidx, double vel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_profile_acceleration_a(DSA_DRIVE_BASE *obj, int sidx, double acc, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_jerk_time_a(DSA_DRIVE_BASE *obj, int sidx, double tim, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_profile_deceleration_a(DSA_DRIVE_BASE *obj, int sidx, double dec, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_end_velocity_a(DSA_DRIVE_BASE *obj, int sidx, double vel, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_source_type_a(DSA_DRIVE_BASE *obj, int typ, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_source_index_a(DSA_DRIVE_BASE *obj, int index, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_shift_factor_a(DSA_DRIVE_BASE *obj, int shift, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_offset_a(DSA_DRIVE_BASE *obj, long offset, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_ctrl_gain_a(DSA_DRIVE_BASE *obj, double gain, DSA_HANDLER handler, void *param);
|
|
|
int _DSA_EXPORT dsa_set_motor_kt_factor_a(DSA_DRIVE_BASE *obj, double kt, DSA_HANDLER handler, void *param);
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
/** @} */
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
} /* extern "C" */
|
|
|
#endif
|
|
|
|
|
|
/**********************************************************************************************************/
|
|
|
/*- C++ WRAPPER CLASSES */
|
|
|
/**********************************************************************************************************/
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSA constants - c++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
|
|
|
#ifdef DSA_OO_API
|
|
|
|
|
|
class Dsa;
|
|
|
class DsaException;
|
|
|
class DsaBase;
|
|
|
class DsaDeviceBase;
|
|
|
class DsaHandlerDeviceBase;
|
|
|
class DsaDevice;
|
|
|
class DsaDeviceGroup;
|
|
|
class DsaDriveBase;
|
|
|
class DsaDrive;
|
|
|
class DsaDriveGroup;
|
|
|
class DsaGantry;
|
|
|
class DsaDsmaxBase;
|
|
|
class DsaDsmax;
|
|
|
class DsaDsmaxGroup;
|
|
|
class DsaIpolGroup;
|
|
|
class DsaGPModuleBase;
|
|
|
class DsaGPModule;
|
|
|
class DsaGPModuleGroup;
|
|
|
class DsaAcquisition;
|
|
|
class DsaRTVData;
|
|
|
class DsaRTVSlot;
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* generate exceptions from error codes
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
#define ERRCHK(a) do { int _err = (a); if(_err) throw DsaException(_err); } while(0)
|
|
|
#define ERRTRANS() do { if(getTransLevel() > 0) throw DsaException(DSA_EBADSTATE); } while(0)
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* asynchronous handler types
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
typedef void (DSA_CALLBACK *DsaHandler)(DsaHandlerDeviceBase dev, int err, void *param);
|
|
|
typedef void (DSA_CALLBACK *DsaIntHandler)(DsaHandlerDeviceBase dev, int err, void *param, int val);
|
|
|
typedef void (DSA_CALLBACK *DsaLongHandler)(DsaHandlerDeviceBase dev, int err, void *param, long val);
|
|
|
typedef void (DSA_CALLBACK *DsaInt64Handler)(DsaHandlerDeviceBase dev, int err, void *param, eint64 val);
|
|
|
typedef void (DSA_CALLBACK *DsaDWordHandler)(DsaHandlerDeviceBase dev, int err, void *param, dword val);
|
|
|
typedef void (DSA_CALLBACK *DsaFloatHandler)(DsaHandlerDeviceBase dev, int err, void *param, float val);
|
|
|
typedef void (DSA_CALLBACK *DsaDoubleHandler)(DsaHandlerDeviceBase dev, int err, void *param, double val);
|
|
|
typedef void (DSA_CALLBACK *DsaStatusHandler)(DsaHandlerDeviceBase dev, int err, void *param, const DsaStatus *stat);
|
|
|
typedef void (DSA_CALLBACK *Dsa2intHandler)(DsaHandlerDeviceBase dev, int err, void *param, int val1, int val2);
|
|
|
typedef void (DSA_CALLBACK *DsaRTVHandler)(DsaHandlerDeviceBase dev, int nr, int nb_read, DSA_RTV_DATA **read_rtv, int nb_write, DSA_RTV_DATA **write_rtv, void *param);
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DSAException Class - c++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaException {
|
|
|
friend class Dsa;
|
|
|
friend class DsaBase;
|
|
|
friend class DsaDeviceBase;
|
|
|
friend class DsaHandlerDeviceBase;
|
|
|
friend class DsaDevice;
|
|
|
friend class DsaDeviceGroup;
|
|
|
friend class DsaDriveBase;
|
|
|
friend class DsaDrive;
|
|
|
friend class DsaDriveGroup;
|
|
|
friend class DsaGantry;
|
|
|
friend class DsaDsmaxBase;
|
|
|
friend class DsaDsmax;
|
|
|
friend class DsaDsmaxGroup;
|
|
|
friend class DsaIpolGroup;
|
|
|
friend class DsaGPModuleBase;
|
|
|
friend class DsaGPModule;
|
|
|
friend class DsaGPModuleGroup;
|
|
|
friend class DsaAcquisition;
|
|
|
friend class DsaRTVData;
|
|
|
friend class DsaRTVSlot;
|
|
|
|
|
|
/* error codes - c++ */
|
|
|
public:
|
|
|
enum {EACQDEVINUSE = -337 }; /* One of the device is already doing an acquisition */
|
|
|
enum {EACQNOTPOSSIBLE = -336 }; /* Drives must be connected with transnet */
|
|
|
enum {EBADDRIVER = -328 }; /* wrong version of the installed device driver */
|
|
|
enum {EBADDRVVER = -325 }; /* a drive with a bad version has been detected */
|
|
|
enum {EBADIPOLGRP = -327 }; /* the ipol group is not correctly defined */
|
|
|
enum {EBADLIBRARY = -333 }; /* function of external library not found */
|
|
|
enum {EBADPARAM = -322 }; /* one of the parameter is not valid */
|
|
|
enum {EBADSEQVERSION = -338 }; /* the sequence version is not correct */
|
|
|
enum {EBADSTATE = -324 }; /* this operation is not allowed in this state */
|
|
|
enum {EBUSERROR = -313 }; /* the underlaying etel-bus is not working fine */
|
|
|
enum {EBUSRESET = -314 }; /* the underlaying etel-bus in performing a reset operation */
|
|
|
enum {ECANCEL = -319 }; /* the transaction has been canceled */
|
|
|
enum {ECONVERT = -317 }; /* a parameter exceeded the permitted range */
|
|
|
enum {EDRVERROR = -311 }; /* drive in error */
|
|
|
enum {EDRVFAILED = -323 }; /* the drive does not operate properly */
|
|
|
enum {EINTERNAL = -316 }; /* some internal error in the etel software */
|
|
|
enum {EMAPNOTACTIVATED = -335 }; /* Mapping cannot be activated by the device */
|
|
|
enum {ENOACK = -312 }; /* no acknowledge from the drive */
|
|
|
enum {ENODRIVE = -320 }; /* the specified drive does not respond */
|
|
|
enum {ENOFREESLOT = -330 }; /* no free slot available */
|
|
|
enum {ENOLIBRARY = -332 }; /* external library not found */
|
|
|
enum {ENOTIMPLEMENTED = -326 }; /* the specified operation is not implemented */
|
|
|
enum {EOBSOLETE = -329 }; /* function is obsolete */
|
|
|
enum {EOPENPORT = -321 }; /* the specified port cannot be open */
|
|
|
enum {ERTVREADSYNCRO = -331 }; /* RTV read synchronisation error */
|
|
|
enum {ESYNTAX = -334 }; /* Mapping file syntax error */
|
|
|
enum {ESYSTEM = -315 }; /* some system resource return an error */
|
|
|
enum {ETIMEOUT = -310 }; /* a timeout has occured */
|
|
|
enum {ETRANS = -318 }; /* a transaction error has occured */
|
|
|
|
|
|
|
|
|
/* exception code */
|
|
|
private:
|
|
|
int code;
|
|
|
|
|
|
/* constructor */
|
|
|
protected:
|
|
|
DsaException(int e) { code = e; };
|
|
|
|
|
|
/* translate error code */
|
|
|
public:
|
|
|
static char_cp translate(int code) {
|
|
|
return dsa_translate_error(code);
|
|
|
}
|
|
|
|
|
|
/* get error description */
|
|
|
public:
|
|
|
int getCode() {
|
|
|
return code;
|
|
|
}
|
|
|
const char *getText() {
|
|
|
return translate(code);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* Dsa Class - c++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class Dsa {
|
|
|
/*
|
|
|
* timeout special values
|
|
|
*/
|
|
|
public:
|
|
|
enum { DEF_TIMEOUT = (-2L) }; /* use the default timeout appropriate for this communication */
|
|
|
|
|
|
/*
|
|
|
* convert special value
|
|
|
*/
|
|
|
public:
|
|
|
enum { CONV_AUTO = -1 }; /* read current drive value, bypass pending commands */
|
|
|
|
|
|
/*
|
|
|
* register kind of access
|
|
|
*/
|
|
|
public:
|
|
|
enum { GET_CURRENT = 0 }; /* read current drive value, bypass pending commands */
|
|
|
enum { GET_WAITING = 1 }; /* read current drive value, waiting pending commands */
|
|
|
enum { GET_TRACE_CURRENT = 2 }; /* get trace array, bypass pending commands */
|
|
|
enum { GET_TRACE_WAITING = 3 }; /* get trace array, waiting pending commands */
|
|
|
enum { GET_CONV_FACTOR = 10 }; /* get the conversion factor */
|
|
|
enum { GET_MIN_VALUE = 11 }; /* get the minimum value */
|
|
|
enum { GET_MAX_VALUE = 12 }; /* get the maximum value */
|
|
|
enum { GET_DEF_VALUE = 13 }; /* get the default value */
|
|
|
|
|
|
/*
|
|
|
* parameters enumeration values - c++
|
|
|
*/
|
|
|
public:
|
|
|
enum { ANALOG = 0 }; /* analog sine/cosine encoder */
|
|
|
enum { CONTINUOUS_CURRENT = 2 }; /* initialisation by sending continous to the motor */
|
|
|
enum { CURRENT_PULSE = 1 }; /* initialisation with current pulses */
|
|
|
enum { DEFAULT_ALL = 0 }; /* restore all informations from ROM default */
|
|
|
enum { DEFAULT_SEQ_LKT = 1 }; /* restore sequence and user lookup-tables from ROM default */
|
|
|
enum { DEFAULT_K_C_PARAMS = 2 }; /* restore K, and KL, KF, KD, C, CL, CF CD if any, parameters from ROM default */
|
|
|
enum { DEFAULT_K_RESET_E_PARAMS = 3 }; /* restore K, KL, KF, KD parameters from ROM default, reset EL parameters*/
|
|
|
enum { DEFAULT_C_PARAMS = 4 }; /* restore C, CL, CF, CD parameters from ROM default */
|
|
|
enum { DEFAULT_X_PARAMS = 5 }; /* reset X, XL, XF, XD parameters */
|
|
|
enum { DEFAULT_L_PARAMS = 6 }; /* reset LD parameters */
|
|
|
enum { DEFAULT_SEQUENCES = 7 }; /* reset sequences */
|
|
|
enum { DEFAULT_E_PARAMS = 8 }; /* reset E parameters */
|
|
|
enum { DEFAULT_P_PARAMS = 9 }; /* reset P parameters */
|
|
|
enum { LOAD_ALL = 0 }; /* load all informations from flash memory */
|
|
|
enum { LOAD_SEQ_LKT = 1 }; /* load sequence and user lookup-tables from flash memory */
|
|
|
enum { LOAD_K_C_E_X_PARAMS = 2 }; /* load K, KL, KF, KD, C, CL, CF, CD, EL, X, XL, XF, XD parameters from flash memory */
|
|
|
enum { LOAD_K_PARAMS = 3 }; /* load K, KL, KF, KD parameters from flash memory */
|
|
|
enum { LOAD_C_PARAMS = 4 }; /* load C, CL, CF, CD parameters from flash memory */
|
|
|
enum { LOAD_X_PARAMS = 5 }; /* load X, XL, XF, XD parameters from flash memory */
|
|
|
enum { LOAD_L_PARAMS = 6 }; /* load LD parameters from flash memory */
|
|
|
enum { LOAD_SEQUENCES = 7 }; /* load sequences from flash memory */
|
|
|
enum { LOAD_E_PARAMS = 8 }; /* load EL parameters from flash memory */
|
|
|
enum { LOAD_P_PARAMS = 9 }; /* load P parameters from flash memory */
|
|
|
enum { SAVE_ALL = 0 }; /* save all informations in flash memory */
|
|
|
enum { SAVE_SEQ_LKT = 1 }; /* save sequence and user lookup-tables in flash memory */
|
|
|
enum { SAVE_K_C_E_X_PARAMS = 2 }; /* save K, KL, KF, KD, C, CL, CF, CD, EL, X, XL, XF, XD parameters in flash memory */
|
|
|
enum { SAVE_K_PARAMS = 3 }; /* save K, KL, KF, KD parameters in flash memory */
|
|
|
enum { SAVE_C_PARAMS = 4 }; /* save C, CL, CF, CD parameters in flash memory */
|
|
|
enum { SAVE_X_PARAMS = 5 }; /* save X, XL, XF, XD parameters in flash memory */
|
|
|
enum { SAVE_L_PARAMS = 6 }; /* save LD parameters in flash memory */
|
|
|
enum { SAVE_SEQUENCES = 7 }; /* save sequences in flash memory */
|
|
|
enum { SAVE_K_E_PARAMS = 8 }; /* save K, KL, KF, KD, EL parameters in flash memory */
|
|
|
enum { SAVE_P_PARAMS = 9 }; /* save P parameters in flash memory */
|
|
|
enum { DISPLAY_ENCODER_SIGNALS = 4 }; /* display encoder's signals */
|
|
|
enum { DISPLAY_NORMAL = 1 }; /* display normal informations */
|
|
|
enum { DISPLAY_SEQUENCE = 8 }; /* display sequence line number */
|
|
|
enum { DISPLAY_TEMPERATURE = 2 }; /* display drive's temperature */
|
|
|
enum { ENABLE_AUTO = 170 }; /* enable signal perform automatic power on of the drive */
|
|
|
enum { ENABLE_NOT_USED = 125 }; /* enable signal not used */
|
|
|
enum { ENABLE_USED = 0 }; /* enable signal is necessary to power on ths drive */
|
|
|
enum { FORCE_REFERENCE = 0 }; /* driver controlled by a force reference */
|
|
|
enum { GATED_INDEX_NEG = 17 }; /* */
|
|
|
enum { GATED_INDEX_NEG_L = 19 }; /* */
|
|
|
enum { GATED_INDEX_POS = 16 }; /* */
|
|
|
enum { GATED_INDEX_POS_L = 18 }; /* */
|
|
|
enum { HALL = 2 }; /* HALL effect encoder */
|
|
|
enum { HOME_INVERTED = 2 }; /* home switch is inverted */
|
|
|
enum { HOME_SW_NEG = 3 }; /* */
|
|
|
enum { HOME_SW_NEG_L = 7 }; /* */
|
|
|
enum { HOME_SW_POS = 2 }; /* */
|
|
|
enum { HOME_SW_POS_L = 6 }; /* */
|
|
|
enum { HOME_SWITCH = 128 }; /* home switch is used */
|
|
|
enum { TRAPEZIODAL_MVT = 0 }; /* trapezoidal motion (jerk = infinite) (obsolete DSB) */
|
|
|
enum { S_CURVE_MVT = 1 }; /* s-curve motion */
|
|
|
enum { RECTANGULAR_MVT = 2 }; /* trapezoidal motion (jerk = 0, acc = infinite) (obsolete DSB) */
|
|
|
enum { PREDEFINED_PROFILE_MVT = 3 }; /* predefined profile motion (DSC family only) */
|
|
|
enum { SLOW_LKT_MVT = 10 }; /* lookup-table motion in profile interrupt (DSC family only)*/
|
|
|
enum { FAST_LKT_MVT = 11 }; /* lookup-table motion in controller interrupt (DSC family only) */
|
|
|
enum { ROTARY_S_CURVE_MVT = 17 }; /* rotary s-curve motion */
|
|
|
enum { ROTARY_PREDEFINED_PROFILE_MVT = 19 }; /* rotary predefined profile motion (DSC family only) */
|
|
|
enum { INFINITE_ROTARY_MVT = 24 }; /* infinite rotary motion */
|
|
|
enum { ROTARY_LKT_MVT = 26 }; /* rotary lookup-table motion (DSC family only) */
|
|
|
enum { INTEGRATOR_IN_POSITION = 1 }; /* integrator off during motion */
|
|
|
enum { INTEGRATOR_OFF = 2 }; /* integrator always off */
|
|
|
enum { INTEGRATOR_ON = 0 }; /* integrator always on */
|
|
|
enum { INVERT_FORCE = 2 }; /* invert current force of the motor */
|
|
|
enum { INVERT_PHASES = 1 }; /* invert phases 1 and 2 of the motor */
|
|
|
enum { LIMIT_SW_NEG = 5 }; /* */
|
|
|
enum { LIMIT_SW_POS = 4 }; /* */
|
|
|
enum { LIMIT_SWITCH = 1 }; /* limit switch are used */
|
|
|
enum { MECHANICAL_NEG = 1 }; /* */
|
|
|
enum { MECHANICAL_POS = 0 }; /* */
|
|
|
enum { MULTI_INDEX_NEG = 13 }; /* */
|
|
|
enum { MULTI_INDEX_NEG_L = 15 }; /* */
|
|
|
enum { MULTI_INDEX_POS = 12 }; /* */
|
|
|
enum { MULTI_INDEX_POS_L = 14 }; /* */
|
|
|
enum { NO_INIT = 0 }; /* no initialisation */
|
|
|
enum { POSITION_PROFILE = 1 }; /* standard position profile mode */
|
|
|
enum { POSITION_REFERENCE = 4 }; /* driver controlled by a position reference */
|
|
|
enum { PULSE_DIRECTION = 5 }; /* pulse and direction mode */
|
|
|
enum { PULSE_DIRECTION_TTL = 6 }; /* pulse and direction mode with TTL encoder */
|
|
|
enum { QS_BYPASS = 2 }; /* bypass all pending command */
|
|
|
enum { QS_INFINITE_DEC = 1 }; /* stop motor with infinite deceleration (step) */
|
|
|
enum { QS_POWER_OFF = 0 }; /* switch off power bridge */
|
|
|
enum { QS_PROGRAMMED_DEC = 2 }; /* stop motor with programmed deceleration */
|
|
|
enum { QS_STOP_SEQUENCE = 1 }; /* also stop the sequence */
|
|
|
enum { REGEN_LIMITED = 2 }; /* regeneration of, max 10s */
|
|
|
enum { REGEN_OFF = 0 }; /* no regeneration */
|
|
|
enum { REGEN_ON = 3 }; /* regeneration always on */
|
|
|
enum { ROTATION_PLAN_XT = 2 }; /* rotation of the XTheta plan */
|
|
|
enum { ROTATION_PLAN_XY = 0 }; /* rotation of the XY plan */
|
|
|
enum { ROTATION_PLAN_XZ = 1 }; /* rotation of the XZ plan */
|
|
|
enum { ROTATION_PLAN_YT = 4 }; /* rotation of the YT plan */
|
|
|
enum { ROTATION_PLAN_YZ = 3 }; /* rotation of the YZ plan */
|
|
|
enum { ROTATION_PLAN_ZT = 5 }; /* rotation of the ZT plan */
|
|
|
enum { SINGLE_INDEX_NEG = 9 }; /* */
|
|
|
enum { SINGLE_INDEX_NEG_L = 11 }; /* */
|
|
|
enum { SINGLE_INDEX_POS = 8 }; /* */
|
|
|
enum { SINGLE_INDEX_POS_L = 10 }; /* */
|
|
|
enum { SOURCE_MONITORING = 3 }; /* monitoring of a monitoring register */
|
|
|
enum { SOURCE_OFF = 0 }; /* no real time monitoring */
|
|
|
enum { SOURCE_PARAMETER = 2 }; /* monitoring of a parameter */
|
|
|
enum { SOURCE_USER_VARIABLE = 1 }; /* monitoring of a user variable */
|
|
|
enum { SPEED_REFERENCE = 3 }; /* driver controlled by a speed reference */
|
|
|
enum { TTL = 1 }; /* TTL encoder */
|
|
|
enum { USER_CHANNEL_12 = 12}; /* user channel 12 */
|
|
|
enum { USER_CHANNEL_13 = 13}; /* user channel 13 */
|
|
|
enum { USER_CHANNEL_14 = 14}; /* user channel 14 */
|
|
|
enum { USER_CHANNEL_15 = 15}; /* user channel 15 */
|
|
|
|
|
|
enum { SCALE_MAPPING_MODE_ZERO_EDGE = 1}; /* 0 will be add at each eand of the scaling area */
|
|
|
enum { SCALE_MAPPING_MODE_SPLINE = 2}; /* the points defined in scaling area will be splined */
|
|
|
|
|
|
enum { SCALE_MAPPING_LINEAR_ACTIVATION = 0}; /* Activation of linear scale-mapping */
|
|
|
enum { SCALE_MAPPING_CYCLIC_ACTIVATION = 1}; /* Activation of cyclic scale-mapping */
|
|
|
|
|
|
/*
|
|
|
* STA-STI flags
|
|
|
*/
|
|
|
public:
|
|
|
enum {STA_POS = 0x01 }; /* get the K210 specified depth as position for the next move*/
|
|
|
enum {STA_SPD = 0x02 }; /* get the K211 specified depth as speed for the next move*/
|
|
|
enum {STA_ACC = 0x04 }; /* get the K212 specified depth as acceleration for the next move*/
|
|
|
enum {STA_JRK = 0x08 }; /* get the K213 specified depth as jerk for the next move*/
|
|
|
/*
|
|
|
* special functions - c++
|
|
|
*/
|
|
|
public:
|
|
|
static DsaDeviceBase createAuto(EtbBus etb, int axis);
|
|
|
static DsaDeviceBase createAuto(int prod);
|
|
|
static DsaDeviceBase etcomCreateAuto(EtbBus etb, int axis);
|
|
|
|
|
|
static DsaStatus initStatus(void) {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
return status;
|
|
|
}
|
|
|
static DsaInfo initInfo(void) {
|
|
|
DsaInfo info = dsa_init_info();
|
|
|
return info;
|
|
|
}
|
|
|
static DsaXInfo initXInfo(void) {
|
|
|
DsaXInfo info = dsa_init_x_info();
|
|
|
return info;
|
|
|
}
|
|
|
static DsaVector initVector(void) {
|
|
|
DsaVector vector = dsa_init_vector();
|
|
|
return vector;
|
|
|
}
|
|
|
static DsaVectorTyp initVectorTyp(void) {
|
|
|
DsaVectorTyp vector_typ = dsa_init_vector_typ();
|
|
|
return vector_typ;
|
|
|
}
|
|
|
static DsaRTM initRtm(void) {
|
|
|
DsaRTM rtm = dsa_init_rtm();
|
|
|
return rtm;
|
|
|
}
|
|
|
static char_cp translateEdiError(int code) {
|
|
|
return dsa_translate_edi_error(code);
|
|
|
}
|
|
|
static void setPrio(int prio) {
|
|
|
ERRCHK(dsa_set_prio(prio));
|
|
|
}
|
|
|
static dword getVersion() {
|
|
|
return dsa_get_version();
|
|
|
}
|
|
|
static time_t getBuildTime() {
|
|
|
return dsa_get_build_time();
|
|
|
}
|
|
|
static dword getTimer() {
|
|
|
return dsa_get_timer();
|
|
|
}
|
|
|
static dword getEdiVersion() {
|
|
|
return dsa_get_edi_version();
|
|
|
}
|
|
|
static void beginSyncTrans() {
|
|
|
ERRCHK(dsa_begin_sync_trans());
|
|
|
}
|
|
|
static void rollbackSyncTrans() {
|
|
|
ERRCHK(dsa_rollback_sync_trans());
|
|
|
}
|
|
|
static void commitSyncTrans(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_commit_sync_trans(timeout));
|
|
|
}
|
|
|
static void beginAsyncTrans() {
|
|
|
ERRCHK(dsa_begin_async_trans());
|
|
|
}
|
|
|
static void rollbackAsyncTrans() {
|
|
|
ERRCHK(dsa_rollback_async_trans());
|
|
|
}
|
|
|
static int getTransLevel() {
|
|
|
int level;
|
|
|
ERRCHK(dsa_get_trans_level(&level));
|
|
|
return level;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaBase Class - c++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaBase: public Dsa {
|
|
|
friend class DsaDeviceBase;
|
|
|
friend class DsaDevice;
|
|
|
friend class DsaDeviceGroup;
|
|
|
friend class DsaDriveBase;
|
|
|
friend class DsaDrive;
|
|
|
friend class DsaDriveGroup;
|
|
|
friend class DsaGantry;
|
|
|
friend class DsaDsmaxBase;
|
|
|
friend class DsaDsmax;
|
|
|
friend class DsaDsmaxGroup;
|
|
|
friend class DsaIpolGroup;
|
|
|
friend class DsaGPModuleBase;
|
|
|
friend class DsaGPModule;
|
|
|
friend class DsaGPModuleGroup;
|
|
|
|
|
|
/*
|
|
|
* member variable
|
|
|
*/
|
|
|
protected:
|
|
|
DSA_DEVICE_BASE *dsa;
|
|
|
|
|
|
/*
|
|
|
* constructors - destructor
|
|
|
*/
|
|
|
protected:
|
|
|
DsaBase(void) {
|
|
|
this->dsa = NULL;
|
|
|
}
|
|
|
DsaBase(DsaBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
//Only destructor of the Dsa devices c++ structure
|
|
|
~DsaBase(void) {
|
|
|
if (dsa)
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
DSA_DEVICE_BASE* getDsaStructure() {
|
|
|
return(dsa);
|
|
|
}
|
|
|
/*
|
|
|
* default operators
|
|
|
*/
|
|
|
protected:
|
|
|
DsaBase operator = (DsaBase &obj) {
|
|
|
return obj;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* hand make functions
|
|
|
*/
|
|
|
DsaBase getGroupItem(int pos) {
|
|
|
DsaBase obj;
|
|
|
ERRCHK(dsa_get_group_item(dsa, pos, &obj.dsa));
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
return obj;
|
|
|
}
|
|
|
DsaDsmax getDsmax(void);
|
|
|
void setDsmax(DsaDsmax dsmax);
|
|
|
|
|
|
/*
|
|
|
* special functions - c++
|
|
|
*/
|
|
|
protected:
|
|
|
void powerOn(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_power_on_s(dsa, timeout));
|
|
|
}
|
|
|
void powerOff(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_power_off_s(dsa, timeout));
|
|
|
}
|
|
|
void newSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_new_setpoint_s(dsa, sidx, flags, timeout));
|
|
|
}
|
|
|
void changeSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_change_setpoint_s(dsa, sidx, flags, timeout));
|
|
|
}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_quick_stop_s(dsa, mode, flags, timeout));
|
|
|
}
|
|
|
void homingStart(long timeout = 10000) {
|
|
|
ERRCHK(dsa_homing_start_s(dsa, timeout));
|
|
|
}
|
|
|
int getWarningCode(int kind, long timeout = DEF_TIMEOUT) {
|
|
|
int code;
|
|
|
ERRCHK(dsa_get_warning_code_s(dsa, &code, kind, timeout));
|
|
|
return code;
|
|
|
}
|
|
|
int getErrorCode(int kind, long timeout = DEF_TIMEOUT) {
|
|
|
int code;
|
|
|
ERRCHK(dsa_get_error_code_s(dsa, &code, kind, timeout));
|
|
|
return code;
|
|
|
}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_s(dsa, cmd, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_d_s(dsa, cmd, typ1, par1, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_i_s(dsa, cmd, typ1, par1, conv1, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_dd_s(dsa, cmd, typ1, par1, typ2, par2, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_id_s(dsa, cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_di_s(dsa, cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_ii_s(dsa, cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout));
|
|
|
}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_command_x_s(dsa, cmd, *(DSA_COMMAND_PARAM **)¶ms, count, fast, ereport, timeout));
|
|
|
}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_profiled_movement_s(dsa, pos, speed, acc, timeout));
|
|
|
}
|
|
|
void startRelativeProfiledMovement(double relativePos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_relative_profiled_movement_s(dsa, relativePos, timeout));
|
|
|
}
|
|
|
|
|
|
long getRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
long val;
|
|
|
ERRCHK(dsa_get_register_s(dsa, typ, idx, sidx, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
long getRegisterInt32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
long val;
|
|
|
ERRCHK(dsa_get_register_int32_s(dsa, typ, idx, sidx, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
eint64 getRegisterInt64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
eint64 val;
|
|
|
ERRCHK(dsa_get_register_int64_s(dsa, typ, idx, sidx, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
float getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
float val;
|
|
|
ERRCHK(dsa_get_register_float32_s(dsa, typ, idx, sidx, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
double getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRCHK(dsa_get_register_float64_s(dsa, typ, idx, sidx, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
float getFloatRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
float val;
|
|
|
ERRCHK(dsa_get_float_register_s(dsa, typ, idx, sidx, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_array_s(dsa, typ, idx, nidx, sidx, val, offset, kind, timeout));
|
|
|
}
|
|
|
void getArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_array_int32_s(dsa, typ, idx, nidx, sidx, val, offset, kind, timeout));
|
|
|
}
|
|
|
void getArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_array_int64_s(dsa, typ, idx, nidx, sidx, val, offset, kind, timeout));
|
|
|
}
|
|
|
void getArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_array_float32_s(dsa, typ, idx, nidx, sidx, val, offset, kind, timeout));
|
|
|
}
|
|
|
void getArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_array_float64_s(dsa, typ, idx, nidx, sidx, val, offset, kind, timeout));
|
|
|
}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_register_s(dsa, typ, idx, sidx, val, timeout));
|
|
|
}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_register_int32_s(dsa, typ, idx, sidx, val, timeout));
|
|
|
}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_register_int64_s(dsa, typ, idx, sidx, val, timeout));
|
|
|
}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_register_float32_s(dsa, typ, idx, sidx, val, timeout));
|
|
|
}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_register_float64_s(dsa, typ, idx, sidx, val, timeout));
|
|
|
}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_float_register_s(dsa, typ, idx, sidx, val, timeout));
|
|
|
}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_array_s(dsa, typ, idx, nidx, sidx, val, offset, timeout));
|
|
|
}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_array_int32_s(dsa, typ, idx, nidx, sidx, val, offset, timeout));
|
|
|
}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_array_int64_s(dsa, typ, idx, nidx, sidx, val, offset, timeout));
|
|
|
}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_array_float32_s(dsa, typ, idx, nidx, sidx, val, offset, timeout));
|
|
|
}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_array_float64_s(dsa, typ, idx, nidx, sidx, val, offset, timeout));
|
|
|
}
|
|
|
double getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRCHK(dsa_get_iso_register_s(dsa, typ, idx, sidx, &val, conv, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_iso_array_s(dsa, typ, idx, nidx, sidx, val, offset, conv, kind, timeout));
|
|
|
}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_iso_register_s(dsa, typ, idx, sidx, val, conv, timeout));
|
|
|
}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_iso_array_s(dsa, typ, idx, nidx, sidx, val, offset, conv, timeout));
|
|
|
}
|
|
|
void ipolBegin(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_begin_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolEnd(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_end_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolBeginConcatenation(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_begin_concatenation_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolEndConcatenation(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_end_concatenation_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolLine(DsaVector *dest, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_line_s(dsa, *(DSA_VECTOR **)&dest, timeout));
|
|
|
}
|
|
|
void ipolCircleCWR2d(double x, double y, double r, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_circle_cw_r2d_s(dsa, x, y, r, timeout));
|
|
|
}
|
|
|
void ipolCircleCcwR2d(double x, double y, double r, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_circle_ccw_r2d_s(dsa, x, y, r, timeout));
|
|
|
}
|
|
|
void ipolTanVelocity(double velocity, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_tan_velocity_s(dsa, velocity, timeout));
|
|
|
}
|
|
|
void ipolTanAcceleration(double acc, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_tan_acceleration_s(dsa, acc, timeout));
|
|
|
}
|
|
|
void ipolTanDeceleration(double dec, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_tan_deceleration_s(dsa, dec, timeout));
|
|
|
}
|
|
|
void ipolTanJerkTime(double jerk_time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_tan_jerk_time_s(dsa, jerk_time, timeout));
|
|
|
}
|
|
|
void ipolQuickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_quick_stop_s(dsa, mode, flags, timeout));
|
|
|
}
|
|
|
void ipolContinue(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_continue_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolReset(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_reset_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolPvt(DsaVector *dest, DsaVector *velocity, double time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_pvt_s(dsa, *(DSA_VECTOR **)&dest, *(DSA_VECTOR **)&velocity, time, timeout));
|
|
|
}
|
|
|
void ipolMark(long number, long operation, long op_param, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_mark_s(dsa, number, operation, op_param, timeout));
|
|
|
}
|
|
|
void ipolMark2Param(long number, long operation, long op_param1, long op_param2, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_mark_2param_s(dsa, number, operation, op_param1, op_param2, timeout));
|
|
|
}
|
|
|
void ipolSetVelocityRate(double rate, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_set_velocity_rate_s(dsa, rate, timeout));
|
|
|
}
|
|
|
void ipolCircleCWC2d(double x, double y, double cx, double cy, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_circle_cw_c2d_s(dsa, x, y, cx, cy, timeout));
|
|
|
}
|
|
|
void ipolCircleCcwC2d(double x, double y, double cx, double cy, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_circle_ccw_c2d_s(dsa, x, y, cx, cy, timeout));
|
|
|
}
|
|
|
void ipolLine(double x, double y, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_line_2d_s(dsa, x, y, timeout));
|
|
|
}
|
|
|
void ipolWaitMovement(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_wait_movement_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolPrepare(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_prepare_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolPvtUpdate(int depth, dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_pvt_update_s(dsa, depth, mask, timeout));
|
|
|
}
|
|
|
void ipolPvtRegTyp(DsaVector *dest, DsaVectorTyp destTyp, DsaVector *velocity, DsaVectorTyp velocityTyp, double time, int timeTyp, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_pvt_reg_typ_s(dsa, *(DSA_VECTOR **)&dest, *(DSA_VECTOR_TYP*)&destTyp, *(DSA_VECTOR **)&velocity, *(DSA_VECTOR_TYP*)&velocityTyp, time, timeTyp, timeout));
|
|
|
}
|
|
|
void ipolSetLktSpeedRatio(double value, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_set_lkt_speed_ratio_s(dsa, value, timeout));
|
|
|
}
|
|
|
void ipolSetLktCyclicMode(bool active, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_set_lkt_cyclic_mode_s(dsa, active, timeout));
|
|
|
}
|
|
|
void ipolSetLktRelativeMode(bool active, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_set_lkt_relative_mode_s(dsa, active, timeout));
|
|
|
}
|
|
|
void ipolLkt(DsaVector *dest, DsaIntVector *lkt_number, double time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_lkt_s(dsa, *(DSA_VECTOR **)&dest, *(DSA_INT_VECTOR **)&lkt_number, time, timeout));
|
|
|
}
|
|
|
void ipolWaitMark(int mark, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_wait_mark_s(dsa, mark, timeout));
|
|
|
}
|
|
|
void ipolUline(DsaVector *dest, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_uline_s(dsa, *(DSA_VECTOR **)&dest, timeout));
|
|
|
}
|
|
|
void ipolUline(double x, double y, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_uline_2d_s(dsa, x, y, timeout));
|
|
|
}
|
|
|
void ipolDisableUconcatenation(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_disable_uconcatenation_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolSetUrelativeMode(bool active, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_set_urelative_mode_s(dsa, active, timeout));
|
|
|
}
|
|
|
void ipolUspeedAxisMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_uspeed_axis_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void ipolUspeed(double speed, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_uspeed_s(dsa, speed, timeout));
|
|
|
}
|
|
|
void ipolUtime(double acc_time, double jerk_time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_utime_s(dsa, acc_time, jerk_time, timeout));
|
|
|
}
|
|
|
void ipolTranslateMatrix(DsaVector *trans, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_translate_matrix_s(dsa, *(DSA_VECTOR **)&trans, timeout));
|
|
|
}
|
|
|
void ipolScaleMatrix(DsaVector *scale, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_scale_matrix_s(dsa, *(DSA_VECTOR **)&scale, timeout));
|
|
|
}
|
|
|
void ipolRotateMatrix(int plan, double degree, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_rotate_matrix_s(dsa, plan, degree, timeout));
|
|
|
}
|
|
|
void ipolTranslateMatrix(double x, double y, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_translate_matrix_2d_s(dsa, x, y, timeout));
|
|
|
}
|
|
|
void ipolScaleMatrix(double x, double y, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_scale_matrix_2d_s(dsa, x, y, timeout));
|
|
|
}
|
|
|
void ipolShearMatrix(int sheared_axis, double axis1_shearing, double axis2_shearing, double axis3_shearing, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_shear_matrix_s(dsa, sheared_axis, axis1_shearing, axis2_shearing, axis3_shearing, timeout));
|
|
|
}
|
|
|
void ipolLock(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_lock_s(dsa, timeout));
|
|
|
}
|
|
|
void ipolUnlock(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_ipol_unlock_s(dsa, timeout));
|
|
|
}
|
|
|
int ipolGetIpolGroup() {
|
|
|
int grp;
|
|
|
ERRCHK(dsa_ipol_get_ipol_grp(dsa, &grp));
|
|
|
return grp;
|
|
|
}
|
|
|
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_quick_register_request_s(dsa, typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, timeout));
|
|
|
}
|
|
|
void quickAddressRequest(dword addr1, long *val1, dword addr2, long *val2, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_quick_address_request_s(dsa, addr1, val1, addr2, val2, timeout));
|
|
|
}
|
|
|
DsaStatus waitStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_wait_status_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, &*(DSA_STATUS *)&status, timeout));
|
|
|
return status;
|
|
|
}
|
|
|
DsaStatus waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_wait_status_not_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, &*(DSA_STATUS *)&status, timeout));
|
|
|
return status;
|
|
|
}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_grp_wait_and_status_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, timeout));
|
|
|
}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_grp_wait_and_status_not_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, timeout));
|
|
|
}
|
|
|
void gantryWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_gantry_wait_and_status_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, timeout));
|
|
|
}
|
|
|
void gantryWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_gantry_wait_and_status_not_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, timeout));
|
|
|
}
|
|
|
DsaStatus waitStatusChange(DsaStatus *mask, long timeout = DEF_TIMEOUT) {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_wait_status_change_s(dsa, *(DSA_STATUS **)&mask, &*(DSA_STATUS *)&status, timeout));
|
|
|
return status;
|
|
|
}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_grp_wait_or_status_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, timeout));
|
|
|
}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_grp_wait_or_status_not_equal_s(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, timeout));
|
|
|
}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trace_mode_mvt_s(dsa, time, endm, timeout));
|
|
|
}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trace_mode_pos_s(dsa, time, pos, timeout));
|
|
|
}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trace_mode_dev_s(dsa, time, level, timeout));
|
|
|
}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trace_mode_iso_s(dsa, time, level, conv, timeout));
|
|
|
}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trace_mode_immediate_s(dsa, time, timeout));
|
|
|
}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_trace_acquisition_s(dsa, typ1, idx1, sidx1, typ2, idx2, sidx2, timeout));
|
|
|
}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_sync_trace_enable_s(dsa, enable, timeout));
|
|
|
}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_sync_trace_force_trigger_s(dsa, timeout));
|
|
|
}
|
|
|
|
|
|
void powerOn(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_power_on_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void powerOff(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_power_off_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void newSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_new_setpoint_a(dsa, sidx, flags, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void changeSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_change_setpoint_a(dsa, sidx, flags, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_quick_stop_a(dsa, mode, flags, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void homingStart(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_homing_start_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void getWarningCode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_warning_code_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getErrorCode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_error_code_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_a(dsa, cmd, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_d_a(dsa, cmd, typ1, par1, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_i_a(dsa, cmd, typ1, par1, conv1, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_dd_a(dsa, cmd, typ1, par1, typ2, par2, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_id_a(dsa, cmd, typ1, par1, conv1, typ2, par2, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_di_a(dsa, cmd, typ1, par1, typ2, par2, conv2, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_ii_a(dsa, cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_command_x_a(dsa, cmd, *(DSA_COMMAND_PARAM **)¶ms, count, fast, ereport, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_start_profiled_movement_a(dsa, pos, speed, acc, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void startRelativeProfiledMovement(double relativePos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_start_relative_profiled_movement_a(dsa, relativePos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
|
|
|
void getRegister(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_register_a(dsa, typ, idx, sidx, kind, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRegisterInt32(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_register_int32_a(dsa, typ, idx, sidx, kind, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRegisterInt64(int typ, unsigned idx, int sidx, int kind, DsaInt64Handler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_register_int64_a(dsa, typ, idx, sidx, kind, (DSA_INT64_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, DsaFloatHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_register_float32_a(dsa, typ, idx, sidx, kind, (DSA_FLOAT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_register_float64_a(dsa, typ, idx, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getFloatRegister(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_float_register_a(dsa, typ, idx, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_array_a(dsa, typ, idx, nidx, sidx, val, offset, kind, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_register_a(dsa, typ, idx, sidx, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_register_int32_a(dsa, typ, idx, sidx, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_register_int64_a(dsa, typ, idx, sidx, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_register_float32_a(dsa, typ, idx, sidx, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_register_float64_a(dsa, typ, idx, sidx, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_float_register_a(dsa, typ, idx, sidx, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_array_a(dsa, typ, idx, nidx, sidx, val, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_array_int32_a(dsa, typ, idx, nidx, sidx, val, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_array_int64_a(dsa, typ, idx, nidx, sidx, val, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_array_float32_a(dsa, typ, idx, nidx, sidx, val, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_array_float64_a(dsa, typ, idx, nidx, sidx, val, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_iso_register_a(dsa, typ, idx, sidx, conv, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_iso_array_a(dsa, typ, idx, nidx, sidx, val, offset, conv, kind, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_iso_register_a(dsa, typ, idx, sidx, val, conv, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_iso_array_a(dsa, typ, idx, nidx, sidx, val, offset, conv, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolBegin(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_begin_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolEnd(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_end_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolBeginConcatenation(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_begin_concatenation_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolEndConcatenation(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_end_concatenation_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolLine(DsaVector *dest, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_line_a(dsa, *(DSA_VECTOR **)&dest, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolCircleCWR2d(double x, double y, double r, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_circle_cw_r2d_a(dsa, x, y, r, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolCircleCcwR2d(double x, double y, double r, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_circle_ccw_r2d_a(dsa, x, y, r, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolTanVelocity(double velocity, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_tan_velocity_a(dsa, velocity, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolTanAcceleration(double acc, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_tan_acceleration_a(dsa, acc, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolTanDeceleration(double dec, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_tan_deceleration_a(dsa, dec, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolTanJerkTime(double jerk_time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_tan_jerk_time_a(dsa, jerk_time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolQuickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_quick_stop_a(dsa, mode, flags, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolContinue(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_continue_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolReset(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_reset_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolPvt(DsaVector *dest, DsaVector *velocity, double time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_pvt_a(dsa, *(DSA_VECTOR **)&dest, *(DSA_VECTOR **)&velocity, time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolMark(long number, long operation, long op_param, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_mark_a(dsa, number, operation, op_param, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolMark2Param(long number, long operation, long op_param1, long op_param2, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_mark_2param_a(dsa, number, operation, op_param1, op_param2, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolSetVelocityRate(double rate, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_set_velocity_rate_a(dsa, rate, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolCircleCWC2d(double x, double y, double cx, double cy, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_circle_cw_c2d_a(dsa, x, y, cx, cy, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolCircleCcwC2d(double x, double y, double cx, double cy, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_circle_ccw_c2d_a(dsa, x, y, cx, cy, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolLine(double x, double y, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_line_2d_a(dsa, x, y, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolWaitMovement(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_wait_movement_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolPrepare(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_prepare_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolPvtUpdate(int depth, dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_pvt_update_a(dsa, depth, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolPvtRegTyp(DsaVector *dest, DsaVectorTyp destTyp, DsaVector *velocity, DsaVectorTyp velocityTyp, double time, int timeTyp, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_pvt_reg_typ_a(dsa, *(DSA_VECTOR **)&dest, *(DSA_VECTOR_TYP*)&destTyp, *(DSA_VECTOR **)&velocity, *(DSA_VECTOR_TYP*)&velocityTyp, time, timeTyp, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolSetLktSpeedRatio(double value, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_set_lkt_speed_ratio_a(dsa, value, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolSetLktCyclicMode(bool active, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_set_lkt_cyclic_mode_a(dsa, active, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolSetLktRelativeMode(bool active, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_set_lkt_relative_mode_a(dsa, active, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolLkt(DsaVector *dest, DsaIntVector *lkt_number, double time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_lkt_a(dsa, *(DSA_VECTOR **)&dest, *(DSA_INT_VECTOR **)&lkt_number, time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolWaitMark(int mark, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_wait_mark_a(dsa, mark, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolUline(DsaVector *dest, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_uline_a(dsa, *(DSA_VECTOR **)&dest, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolUline(double x, double y, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_uline_2d_a(dsa, x, y, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolDisableUconcatenation(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_disable_uconcatenation_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolSetUrelativeMode(bool active, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_set_urelative_mode_a(dsa, active, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolUspeedAxisMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_uspeed_axis_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolUspeed(double speed, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_uspeed_a(dsa, speed, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolUtime(double acc_time, double jerk_time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_utime_a(dsa, acc_time, jerk_time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolTranslateMatrix(DsaVector *trans, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_translate_matrix_a(dsa, *(DSA_VECTOR **)&trans, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolScaleMatrix(DsaVector *scale, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_scale_matrix_a(dsa, *(DSA_VECTOR **)&scale, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolRotateMatrix(int plan, double degree, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_rotate_matrix_a(dsa, plan, degree, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolTranslateMatrix(double x, double y, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_translate_matrix_2d_a(dsa, x, y, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolScaleMatrix(double x, double y, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_scale_matrix_2d_a(dsa, x, y, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolShearMatrix(int sheared_axis, double axis1_shearing, double axis2_shearing, double axis3_shearing, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_shear_matrix_a(dsa, sheared_axis, axis1_shearing, axis2_shearing, axis3_shearing, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolLock(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_lock_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void ipolUnlock(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_ipol_unlock_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, Dsa2intHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_quick_register_request_a(dsa, typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, (DSA_2INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void quickAddressRequest(dword addr1, long *val1, dword addr2, long *val2, Dsa2intHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_quick_address_request_a(dsa, addr1, val1, addr2, val2, (DSA_2INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_status_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_STATUS_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_status_not_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_STATUS_HANDLER)handler, param));
|
|
|
}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_grp_wait_and_status_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_grp_wait_and_status_not_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void gantryWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_gantry_wait_and_status_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void gantryWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_gantry_wait_and_status_not_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitStatusChange(DsaStatus *mask, DsaStatusHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_status_change_a(dsa, *(DSA_STATUS **)&mask, (DSA_STATUS_HANDLER)handler, param));
|
|
|
}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_grp_wait_or_status_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_grp_wait_or_status_not_equal_a(dsa, *(DSA_STATUS **)&mask, *(DSA_STATUS **)&ref, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trace_mode_mvt_a(dsa, time, endm, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trace_mode_pos_a(dsa, time, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trace_mode_dev_a(dsa, time, level, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trace_mode_iso_a(dsa, time, level, conv, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trace_mode_immediate_a(dsa, time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_trace_acquisition_a(dsa, typ1, idx1, sidx1, typ2, idx2, sidx2, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_sync_trace_enable_a(dsa, enable, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_sync_trace_force_trigger_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
|
|
|
void open(EtbBus etb, int axis) {
|
|
|
ERRCHK(dsa_open_e(dsa, *(ETB **)&etb, axis));
|
|
|
}
|
|
|
void etcomOpen(EtbBus etb, int axis) {
|
|
|
ERRCHK(dsa_etcom_open_e(dsa, *(ETB **)&etb, axis));
|
|
|
}
|
|
|
void open(char_cp url) {
|
|
|
ERRCHK(dsa_open_u(dsa, url));
|
|
|
}
|
|
|
void open(EtbBus etb, int axis, dword flags) {
|
|
|
ERRCHK(dsa_open_ef(dsa, *(ETB **)&etb, axis, flags));
|
|
|
}
|
|
|
void etcomOpen(EtbBus etb, int axis, dword flags) {
|
|
|
ERRCHK(dsa_etcom_open_ef(dsa, *(ETB **)&etb, axis, flags));
|
|
|
}
|
|
|
void reset() {
|
|
|
ERRCHK(dsa_reset(dsa));
|
|
|
}
|
|
|
void close() {
|
|
|
ERRCHK(dsa_close(dsa));
|
|
|
}
|
|
|
EtbBus getEtbBus() {
|
|
|
EtbBus etb;
|
|
|
ERRCHK(dsa_get_etb_bus(dsa, &*(ETB **)&etb));
|
|
|
return etb;
|
|
|
}
|
|
|
int getEtbAxis() {
|
|
|
int axis;
|
|
|
ERRCHK(dsa_get_etb_axis(dsa, &axis));
|
|
|
return axis;
|
|
|
}
|
|
|
int etcomGetEtbAxis() {
|
|
|
int axis;
|
|
|
ERRCHK(dsa_etcom_get_etb_axis(dsa, &axis));
|
|
|
return axis;
|
|
|
}
|
|
|
bool isOpen() {
|
|
|
bool is_open;
|
|
|
ERRCHK(dsa_is_open(dsa, &is_open));
|
|
|
return is_open;
|
|
|
}
|
|
|
int getMotorTyp() {
|
|
|
return dsa_get_motor_typ(dsa);
|
|
|
}
|
|
|
int getFamily() {
|
|
|
DMD_FAMILY family;
|
|
|
ERRCHK(dsa_get_family(dsa, &family));
|
|
|
return family;
|
|
|
}
|
|
|
DmdData getDmdData() {
|
|
|
DmdData dmd;
|
|
|
ERRCHK(dsa_get_dmd_data(dsa, (DMD **)&dmd));
|
|
|
return dmd;
|
|
|
}
|
|
|
|
|
|
void getErrorText(char_p text, int size, int code) {
|
|
|
ERRCHK(dsa_get_error_text(dsa, text, size, code));
|
|
|
}
|
|
|
void getWarningText(char_p text, int size, int code) {
|
|
|
ERRCHK(dsa_get_warning_text(dsa, text, size, code));
|
|
|
}
|
|
|
double convertToIso(long inc, int conv) {
|
|
|
double iso;
|
|
|
ERRCHK(dsa_convert_to_iso(dsa, &iso, inc, conv));
|
|
|
return iso;
|
|
|
}
|
|
|
double convertInt32ToIso(long inc, int conv) {
|
|
|
double iso;
|
|
|
ERRCHK(dsa_convert_int32_to_iso(dsa, &iso, inc, conv));
|
|
|
return iso;
|
|
|
}
|
|
|
double convertInt64ToIso(eint64 inc, int conv) {
|
|
|
double iso;
|
|
|
ERRCHK(dsa_convert_int64_to_iso(dsa, &iso, inc, conv));
|
|
|
return iso;
|
|
|
}
|
|
|
double convertFloat32ToIso(float inc, int conv) {
|
|
|
double iso;
|
|
|
ERRCHK(dsa_convert_float32_to_iso(dsa, &iso, inc, conv));
|
|
|
return iso;
|
|
|
}
|
|
|
double convertFloat64ToIso(double inc, int conv) {
|
|
|
double iso;
|
|
|
ERRCHK(dsa_convert_float64_to_iso(dsa, &iso, inc, conv));
|
|
|
return iso;
|
|
|
}
|
|
|
long convertFromIso(double iso, int conv) {
|
|
|
long inc;
|
|
|
ERRCHK(dsa_convert_from_iso(dsa, &inc, iso, conv));
|
|
|
return inc;
|
|
|
}
|
|
|
long convertInt32FromIso(double iso, int conv) {
|
|
|
long inc;
|
|
|
ERRCHK(dsa_convert_int32_from_iso(dsa, &inc, iso, conv));
|
|
|
return inc;
|
|
|
}
|
|
|
eint64 convertInt64FromIso(double iso, int conv) {
|
|
|
eint64 inc;
|
|
|
ERRCHK(dsa_convert_int64_from_iso(dsa, &inc, iso, conv));
|
|
|
return inc;
|
|
|
}
|
|
|
float convertFloat32FromIso(double iso, int conv) {
|
|
|
float inc;
|
|
|
ERRCHK(dsa_convert_float32_from_iso(dsa, &inc, iso, conv));
|
|
|
return inc;
|
|
|
}
|
|
|
double convertFloat64FromIso(double iso, int conv) {
|
|
|
double inc;
|
|
|
ERRCHK(dsa_convert_float64_from_iso(dsa, &inc, iso, conv));
|
|
|
return inc;
|
|
|
}
|
|
|
double getIncToIsoFactor(int conv) {
|
|
|
double factor;
|
|
|
ERRCHK(dsa_get_inc_to_iso_factor(dsa, conv, &factor));
|
|
|
return factor;
|
|
|
}
|
|
|
void getRtmMon(DsaRTM *rtm) {
|
|
|
ERRCHK(dsa_get_rtm_mon(dsa, *(DSA_RTM **)&rtm));
|
|
|
}
|
|
|
void initRtmFct() {
|
|
|
ERRCHK(dsa_init_rtm_fct(dsa));
|
|
|
}
|
|
|
void startRtm(DsaTrajectoryHandler fct) {
|
|
|
ERRCHK(dsa_start_rtm(dsa, *(DSA_TRAJECTORY_HANDLER*)&fct));
|
|
|
}
|
|
|
void stopRtm() {
|
|
|
ERRCHK(dsa_stop_rtm(dsa));
|
|
|
}
|
|
|
void diag(char_cp file_name, int line, int err) {
|
|
|
ERRCHK(dsa_diag(file_name, line, err, dsa));
|
|
|
}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {
|
|
|
ERRCHK(dsa_sdiag(str, file_name, line, err, dsa));
|
|
|
}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {
|
|
|
ERRCHK(dsa_fdiag(output_file_name, file_name, line, err, dsa));
|
|
|
}
|
|
|
void extDiag(char_cp file_name, int line, int err) {
|
|
|
ERRCHK(dsa_ext_diag(file_name, line, err, dsa));
|
|
|
}
|
|
|
void extSdiag(int size, char_p str, char_cp file_name, int line, int err) {
|
|
|
ERRCHK(dsa_ext_sdiag(size, str, file_name, line, err, dsa));
|
|
|
}
|
|
|
void extFdiag(char_cp output_file_name, char_cp file_name, int line, int err) {
|
|
|
ERRCHK(dsa_ext_fdiag(output_file_name, file_name, line, err, dsa));
|
|
|
}
|
|
|
int getGroupSize() {
|
|
|
int size;
|
|
|
ERRCHK(dsa_get_group_size(dsa, &size));
|
|
|
return size;
|
|
|
}
|
|
|
int gantryGetErrorCode(int *axis, int kind) {
|
|
|
int code;
|
|
|
ERRCHK(dsa_gantry_get_error_code(dsa, &code, axis, kind));
|
|
|
return code;
|
|
|
}
|
|
|
DsaInfo getInfo() {
|
|
|
DsaInfo info = dsa_init_info();
|
|
|
ERRCHK(dsa_get_info(dsa, &*(DSA_INFO *)&info));
|
|
|
return info;
|
|
|
}
|
|
|
bool isIpolINProgress() {
|
|
|
return dsa_is_ipol_in_progress(dsa);
|
|
|
}
|
|
|
DsaStatus getStatus() {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_get_status(dsa, &*(DSA_STATUS *)&status));
|
|
|
return status;
|
|
|
}
|
|
|
void cancelStatusWait() {
|
|
|
ERRCHK(dsa_cancel_status_wait(dsa));
|
|
|
}
|
|
|
void gantryCancelStatusWait() {
|
|
|
ERRCHK(dsa_gantry_cancel_status_wait(dsa));
|
|
|
}
|
|
|
DsaStatus gantryGetAndStatus() {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_gantry_get_and_status(dsa, &*(DSA_STATUS *)&status));
|
|
|
return status;
|
|
|
}
|
|
|
DsaStatus gantryGetORStatus() {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_gantry_get_or_status(dsa, &*(DSA_STATUS *)&status));
|
|
|
return status;
|
|
|
}
|
|
|
DsaStatus getStatusFromDrive(long timeout = DEF_TIMEOUT) {
|
|
|
DsaStatus status = dsa_init_status();
|
|
|
ERRCHK(dsa_get_status_from_drive(dsa, &*(DSA_STATUS *)&status, timeout));
|
|
|
return status;
|
|
|
}
|
|
|
void grpCancelStatusWait() {
|
|
|
ERRCHK(dsa_grp_cancel_status_wait(dsa));
|
|
|
}
|
|
|
double queryMinimumSampleTime() {
|
|
|
double time;
|
|
|
ERRCHK(dsa_query_minimum_sample_time(dsa, &time));
|
|
|
return time;
|
|
|
}
|
|
|
double querySampleTime(double time) {
|
|
|
double real_time;
|
|
|
ERRCHK(dsa_query_sample_time(dsa, time, &real_time));
|
|
|
return real_time;
|
|
|
}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_commit_async_trans(dsa, *(DSA_HANDLER*)&handler, param));
|
|
|
}
|
|
|
DsaXInfo getXInfo() {
|
|
|
DsaXInfo x_info = dsa_init_x_info();
|
|
|
ERRCHK(dsa_get_x_info(dsa, &*(DSA_X_INFO *)&x_info));
|
|
|
return x_info;
|
|
|
}
|
|
|
void stageMappingDownload(const char *fileName) {
|
|
|
ERRCHK(dsa_stage_mapping_download(dsa, fileName));
|
|
|
}
|
|
|
void stageMappingUpload(const char *fileName) {
|
|
|
ERRCHK(dsa_stage_mapping_upload(dsa, fileName));
|
|
|
}
|
|
|
void stageMappingActivate() {
|
|
|
ERRCHK(dsa_stage_mapping_activate(dsa));
|
|
|
}
|
|
|
void stageMappingDeactivate() {
|
|
|
ERRCHK(dsa_stage_mapping_deactivate(dsa));
|
|
|
}
|
|
|
bool stageMappingIsActivated() {
|
|
|
bool active;
|
|
|
ERRCHK(dsa_stage_mapping_get_activation(dsa, &active));
|
|
|
return active;
|
|
|
}
|
|
|
void scaleMappingDownload(const char *fileName, dword preProcessingMode) {
|
|
|
ERRCHK(dsa_scale_mapping_download(dsa, fileName, preProcessingMode));
|
|
|
}
|
|
|
void scaleMappingActivate(dword mode) {
|
|
|
ERRCHK(dsa_scale_mapping_activate(dsa, mode));
|
|
|
}
|
|
|
void scaleMappingDeactivate() {
|
|
|
ERRCHK(dsa_scale_mapping_deactivate(dsa));
|
|
|
}
|
|
|
bool scaleMappingIsActivated() {
|
|
|
bool active;
|
|
|
ERRCHK(dsa_scale_mapping_get_activation(dsa, &active));
|
|
|
return active;
|
|
|
}
|
|
|
void startUploadTrace(int traceTyp, int traceIdx, int startIdx, int endIdx, int stepIdx, bool fast, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_upload_trace_s(dsa, traceTyp, traceIdx, startIdx, endIdx, stepIdx, fast, timeout));
|
|
|
}
|
|
|
void startUploadSequence(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_upload_sequence_s(dsa, timeout));
|
|
|
}
|
|
|
void startUploadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_upload_register_s(dsa, typ, startIdx, endIdx, sidx, timeout));
|
|
|
}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_download_sequence_s(dsa, timeout));
|
|
|
}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_download_register_s(dsa, typ, startIdx, endIdx, sidx, timeout));
|
|
|
}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_download_data_s(dsa, data, size, timeout));
|
|
|
}
|
|
|
void uploadData(void *data, int size, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_upload_data_s(dsa, data, size, timeout));
|
|
|
}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {
|
|
|
ERRCHK(dsa_download_compiled_sequence_file(dsa, fileName));
|
|
|
}
|
|
|
void setSequenceVersion(char *fileName) {
|
|
|
ERRCHK(dsa_set_sequence_version(dsa, fileName));
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* commands - synchronous
|
|
|
*/
|
|
|
protected:
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_reset_error_s(dsa, timeout));
|
|
|
}
|
|
|
void stepMotion(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_step_motion_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_sequence_s(dsa, label, timeout));
|
|
|
}
|
|
|
void executeSequenceInThread(int label, int thread_nr, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_execute_sequence_in_thread_s(dsa, label, thread_nr, timeout));
|
|
|
}
|
|
|
void stopSequenceInThread(int thread_nr, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_stop_sequence_in_thread_s(dsa, thread_nr, timeout));
|
|
|
}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_stop_sequence_s(dsa, timeout));
|
|
|
}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_edit_sequence_s(dsa, timeout));
|
|
|
}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_exit_sequence_s(dsa, timeout));
|
|
|
}
|
|
|
void canCommand1(dword val1, dword val2, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_can_command_1_s(dsa, val1, val2, timeout));
|
|
|
}
|
|
|
void canCommand2(dword val1, dword val2, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_can_command_2_s(dsa, val1, val2, timeout));
|
|
|
}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_save_parameters_s(dsa, what, timeout));
|
|
|
}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_load_parameters_s(dsa, what, timeout));
|
|
|
}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_default_parameters_s(dsa, what, timeout));
|
|
|
}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_movement_s(dsa, timeout));
|
|
|
}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_position_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_time_s(dsa, time, timeout));
|
|
|
}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_window_s(dsa, timeout));
|
|
|
}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_bit_set_s(dsa, typ, idx, sidx, mask, timeout));
|
|
|
}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_bit_clear_s(dsa, typ, idx, sidx, mask, timeout));
|
|
|
}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_sgn_register_greater_s(dsa, typ, idx, sidx, value, timeout));
|
|
|
}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_sgn_register_lower_s(dsa, typ, idx, sidx, value, timeout));
|
|
|
}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_window_user_channel_s(dsa, channel, timeout));
|
|
|
}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_movement_user_channel_s(dsa, channel, timeout));
|
|
|
}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_time_user_channel_s(dsa, time, channel, timeout));
|
|
|
}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_time_user_channel_s(dsa, position, channel, timeout));
|
|
|
}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_sgn_register_greater_user_channel_s(dsa, typ, idx, sidx, value, channel, timeout));
|
|
|
}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_sgn_register_lower_user_channel_s(dsa, typ, idx, sidx, value, channel, timeout));
|
|
|
}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_bit_set_user_channel_s(dsa, typ, idx, sidx, mask, channel, timeout));
|
|
|
}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_wait_bit_clear_user_channel_s(dsa, typ, idx, sidx, mask, channel, timeout));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* commands - asynchronous
|
|
|
*/
|
|
|
protected:
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_reset_error_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void stepMotion(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_step_motion_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_sequence_a(dsa, label, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void executeSequenceInThread(int label, int thread_nr, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_execute_sequence_in_thread_a(dsa, label, thread_nr, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void stopSequenceInThread(int thread_nr, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_stop_sequence_in_thread_a(dsa, thread_nr, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_stop_sequence_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_edit_sequence_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_exit_sequence_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void canCommand1(dword val1, dword val2, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_can_command_1_a(dsa, val1, val2, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void canCommand2(dword val1, dword val2, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_can_command_2_a(dsa, val1, val2, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_save_parameters_a(dsa, what, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_load_parameters_a(dsa, what, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_default_parameters_a(dsa, what, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_movement_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_position_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_time_a(dsa, time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_window_a(dsa, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_bit_set_a(dsa, typ, idx, sidx, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_bit_clear_a(dsa, typ, idx, sidx, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_sgn_register_greater_a(dsa, typ, idx, sidx, value, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_sgn_register_lower_a(dsa, typ, idx, sidx, value, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_window_user_channel_a(dsa, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_movement_user_channel_a(dsa, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_time_user_channel_a(dsa, time, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_time_user_channel_a(dsa, position, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_sgn_register_greater_user_channel_a(dsa, typ, idx, sidx, value, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_sgn_register_lower_user_channel_a(dsa, typ, idx, sidx, value, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_bit_set_user_channel_a(dsa, typ, idx, sidx, mask, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_wait_bit_clear_user_channel_a(dsa, typ, idx, sidx, mask, channel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* register setter - synchronous
|
|
|
*/
|
|
|
protected:
|
|
|
void setPLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_proportional_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setPLSpeedFeedbackGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_speed_feedback_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setPLForceFeedbackGain1(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_force_feedback_gain_1_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setPLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_integrator_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setPLAntiWindupGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_anti_windup_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setPLIntegratorLimitation(double limit, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_integrator_limitation_s(dsa, limit, timeout));
|
|
|
}
|
|
|
void setPLIntegratorMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_integrator_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setPLSpeedFilter(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_speed_filter_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setPLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_output_filter_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setCLInputFilter(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_input_filter_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setTtlSpecialFilter(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ttl_special_filter_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setPLForceFeedbackGain2(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_force_feedback_gain_2_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setPLSpeedFeedfwdGain(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_speed_feedfwd_gain_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setPLAccFeedforwardGain(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pl_acc_feedforward_gain_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setCLPhaseAdvanceFactor(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_phase_advance_factor_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setAprInputFilter(double time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_apr_input_filter_s(dsa, time, timeout));
|
|
|
}
|
|
|
void setCLPhaseAdvanceShift(double shift, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_phase_advance_shift_s(dsa, shift, timeout));
|
|
|
}
|
|
|
void setMinPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_min_position_range_limit_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setMaxPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_max_position_range_limit_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setMaxProfileVelocity(double vel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_max_profile_velocity_s(dsa, vel, timeout));
|
|
|
}
|
|
|
void setMaxAcceleration(double acc, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_max_acceleration_s(dsa, acc, timeout));
|
|
|
}
|
|
|
void startMovement(double *targets, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_start_movement_s(dsa, targets, timeout));
|
|
|
}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_following_error_window_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setVelocityErrorLimit(double vel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_velocity_error_limit_s(dsa, vel, timeout));
|
|
|
}
|
|
|
void setSwitchLimitMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_switch_limit_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setEnableInputMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_enable_input_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setMinSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_min_soft_position_limit_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setMaxSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_max_soft_position_limit_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setProfileLimitMode(dword flags, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_profile_limit_mode_s(dsa, flags, timeout));
|
|
|
}
|
|
|
void setIOErrorEventMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_io_error_event_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setPositionWindowTime(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_position_window_time_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setPositionWindow(double win, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_position_window_s(dsa, win, timeout));
|
|
|
}
|
|
|
void setHomingMethod(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_method_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setHomingZeroSpeed(double vel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_zero_speed_s(dsa, vel, timeout));
|
|
|
}
|
|
|
void setHomingAcceleration(double acc, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_acceleration_s(dsa, acc, timeout));
|
|
|
}
|
|
|
void setHomingFollowingLimit(double win, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_following_limit_s(dsa, win, timeout));
|
|
|
}
|
|
|
void setHomingCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_current_limit_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setHomeOffset(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_home_offset_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setHomingFixedMvt(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_fixed_mvt_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setHomingSwitchMvt(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_switch_mvt_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setHomingIndexMvt(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_index_mvt_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setHomingFineTuningMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_fine_tuning_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setHomingFineTuningValue(double phase, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_homing_fine_tuning_value_s(dsa, phase, timeout));
|
|
|
}
|
|
|
void setMotorPhaseCorrection(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_motor_phase_correction_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setSoftwareCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_software_current_limit_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setDriveControlMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_drive_control_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setDisplayMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_display_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setEncoderInversion(double invert, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_inversion_s(dsa, invert, timeout));
|
|
|
}
|
|
|
void setPdrStepValue(double step, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_pdr_step_value_s(dsa, step, timeout));
|
|
|
}
|
|
|
void setEncoderPhase1Offset(double offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_phase_1_offset_s(dsa, offset, timeout));
|
|
|
}
|
|
|
void setEncoderPhase2Offset(double offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_phase_2_offset_s(dsa, offset, timeout));
|
|
|
}
|
|
|
void setEncoderPhase1Factor(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_phase_1_factor_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setEncoderPhase2Factor(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_phase_2_factor_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setEncoderPhase3Offset(double offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_phase_3_offset_s(dsa, offset, timeout));
|
|
|
}
|
|
|
void setEncoderIndexDistance(double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_index_distance_s(dsa, pos, timeout));
|
|
|
}
|
|
|
void setEncoderPhase3Factor(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_encoder_phase_3_factor_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setCLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_proportional_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setCLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_integrator_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setCLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_output_filter_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setCLCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_current_limit_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setCLI2tCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_i2t_current_limit_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setCLI2tTimeLimit(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_i2t_time_limit_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setCLRegenMode(int mode, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_cl_regen_mode_s(dsa, mode, timeout));
|
|
|
}
|
|
|
void setInitMode(int typ, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_mode_s(dsa, typ, timeout));
|
|
|
}
|
|
|
void setInitPulseLevel(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_pulse_level_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setInitMaxCurrent(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_max_current_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setInitFinalPhase(double cal, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_final_phase_s(dsa, cal, timeout));
|
|
|
}
|
|
|
void setInitTime(double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_time_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setInitCurrentRate(double cur, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_current_rate_s(dsa, cur, timeout));
|
|
|
}
|
|
|
void setInitPhaseRate(double cal, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_phase_rate_s(dsa, cal, timeout));
|
|
|
}
|
|
|
void setInitInitialPhase(double cal, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_init_initial_phase_s(dsa, cal, timeout));
|
|
|
}
|
|
|
void setDriveFuseChecking(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_drive_fuse_checking_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setMotorTempChecking(dword val, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_motor_temp_checking_s(dsa, val, timeout));
|
|
|
}
|
|
|
void setMonSourceType(int sidx, int typ, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mon_source_type_s(dsa, sidx, typ, timeout));
|
|
|
}
|
|
|
void setMonSourceIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mon_source_index_s(dsa, sidx, index, timeout));
|
|
|
}
|
|
|
void setMonDestIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mon_dest_index_s(dsa, sidx, index, timeout));
|
|
|
}
|
|
|
void setMonOffset(int sidx, long offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mon_offset_s(dsa, sidx, offset, timeout));
|
|
|
}
|
|
|
void setMonGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mon_gain_s(dsa, sidx, gain, timeout));
|
|
|
}
|
|
|
void setXAnalogOffset(int sidx, double offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_analog_offset_s(dsa, sidx, offset, timeout));
|
|
|
}
|
|
|
void setXAnalogGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_analog_gain_s(dsa, sidx, gain, timeout));
|
|
|
}
|
|
|
void setSyncroInputMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_syncro_input_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setSyncroInputValue(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_syncro_input_value_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setSyncroOutputMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_syncro_output_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setSyncroOutputValue(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_syncro_output_value_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setSyncroStartTimeout(int tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_syncro_start_timeout_s(dsa, tim, timeout));
|
|
|
}
|
|
|
void setDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_digital_output_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setXDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_digital_output_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setXAnalogOutput1(double out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_analog_output_1_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setXAnalogOutput2(double out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_analog_output_2_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setXAnalogOutput3(double out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_analog_output_3_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setXAnalogOutput4(double out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_x_analog_output_4_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setAnalogOutput(double out, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_analog_output_s(dsa, out, timeout));
|
|
|
}
|
|
|
void setInterruptMask1(int sidx, dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_interrupt_mask_1_s(dsa, sidx, mask, timeout));
|
|
|
}
|
|
|
void setInterruptMask2(int sidx, dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_interrupt_mask_2_s(dsa, sidx, mask, timeout));
|
|
|
}
|
|
|
void setTriggerIrqMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trigger_irq_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setTriggerIOMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trigger_io_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setTriggerMapOffset(int offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trigger_map_offset_s(dsa, offset, timeout));
|
|
|
}
|
|
|
void setTriggerMapSize(int size, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_trigger_map_size_s(dsa, size, timeout));
|
|
|
}
|
|
|
void setRealtimeEnabledGlobal(int enable, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_realtime_enabled_global_s(dsa, enable, timeout));
|
|
|
}
|
|
|
void setRealtimeValidMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_realtime_valid_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setRealtimeEnabledMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_realtime_enabled_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setRealtimePendingMask(dword mask, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_realtime_pending_mask_s(dsa, mask, timeout));
|
|
|
}
|
|
|
void setEblBaudrate(long baud, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ebl_baudrate_s(dsa, baud, timeout));
|
|
|
}
|
|
|
void setIndirectAxisNumber(int axis, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_indirect_axis_number_s(dsa, axis, timeout));
|
|
|
}
|
|
|
void setIndirectRegisterIdx(int idx, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_indirect_register_idx_s(dsa, idx, timeout));
|
|
|
}
|
|
|
void setIndirectRegisterSidx(int sidx, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_indirect_register_sidx_s(dsa, sidx, timeout));
|
|
|
}
|
|
|
void setConcatenatedMvt(int concat, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_concatenated_mvt_s(dsa, concat, timeout));
|
|
|
}
|
|
|
void setProfileType(int sidx, int typ, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_profile_type_s(dsa, sidx, typ, timeout));
|
|
|
}
|
|
|
void setMvtLktNumber(int sidx, int number, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mvt_lkt_number_s(dsa, sidx, number, timeout));
|
|
|
}
|
|
|
void setMvtLktTime(int sidx, double time, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_mvt_lkt_time_s(dsa, sidx, time, timeout));
|
|
|
}
|
|
|
void setCameValue(double factor, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_came_value_s(dsa, factor, timeout));
|
|
|
}
|
|
|
void setBrakeDeceleration(double dec, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_brake_deceleration_s(dsa, dec, timeout));
|
|
|
}
|
|
|
void setTargetPosition(int sidx, double pos, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_target_position_s(dsa, sidx, pos, timeout));
|
|
|
}
|
|
|
void setProfileVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_profile_velocity_s(dsa, sidx, vel, timeout));
|
|
|
}
|
|
|
void setProfileAcceleration(int sidx, double acc, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_profile_acceleration_s(dsa, sidx, acc, timeout));
|
|
|
}
|
|
|
void setJerkTime(int sidx, double tim, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_jerk_time_s(dsa, sidx, tim, timeout));
|
|
|
}
|
|
|
void setProfileDeceleration(int sidx, double dec, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_profile_deceleration_s(dsa, sidx, dec, timeout));
|
|
|
}
|
|
|
void setEndVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_end_velocity_s(dsa, sidx, vel, timeout));
|
|
|
}
|
|
|
void setCtrlSourceType(int typ, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ctrl_source_type_s(dsa, typ, timeout));
|
|
|
}
|
|
|
void setCtrlSourceIndex(int index, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ctrl_source_index_s(dsa, index, timeout));
|
|
|
}
|
|
|
void setCtrlShiftFactor(int shift, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ctrl_shift_factor_s(dsa, shift, timeout));
|
|
|
}
|
|
|
void setCtrlOffset(long offset, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ctrl_offset_s(dsa, offset, timeout));
|
|
|
}
|
|
|
void setCtrlGain(double gain, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_ctrl_gain_s(dsa, gain, timeout));
|
|
|
}
|
|
|
void setMotorKTFactor(double kt, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_set_motor_kt_factor_s(dsa, kt, timeout));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* register setter - asynchronous
|
|
|
*/
|
|
|
protected:
|
|
|
void setPLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_proportional_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLSpeedFeedbackGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_speed_feedback_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLForceFeedbackGain1(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_force_feedback_gain_1_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_integrator_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLAntiWindupGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_anti_windup_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLIntegratorLimitation(double limit, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_integrator_limitation_a(dsa, limit, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLIntegratorMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_integrator_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLSpeedFilter(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_speed_filter_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_output_filter_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLInputFilter(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_input_filter_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTtlSpecialFilter(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ttl_special_filter_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLForceFeedbackGain2(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_force_feedback_gain_2_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLSpeedFeedfwdGain(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_speed_feedfwd_gain_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPLAccFeedforwardGain(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pl_acc_feedforward_gain_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLPhaseAdvanceFactor(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_phase_advance_factor_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setAprInputFilter(double time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_apr_input_filter_a(dsa, time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLPhaseAdvanceShift(double shift, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_phase_advance_shift_a(dsa, shift, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMinPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_min_position_range_limit_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMaxPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_max_position_range_limit_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMaxProfileVelocity(double vel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_max_profile_velocity_a(dsa, vel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMaxAcceleration(double acc, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_max_acceleration_a(dsa, acc, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void startMovement(double *targets, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_start_movement_a(dsa, targets, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_following_error_window_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setVelocityErrorLimit(double vel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_velocity_error_limit_a(dsa, vel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSwitchLimitMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_switch_limit_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEnableInputMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_enable_input_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMinSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_min_soft_position_limit_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMaxSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_max_soft_position_limit_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setProfileLimitMode(dword flags, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_profile_limit_mode_a(dsa, flags, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setIOErrorEventMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_io_error_event_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPositionWindowTime(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_position_window_time_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPositionWindow(double win, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_position_window_a(dsa, win, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingMethod(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_method_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingZeroSpeed(double vel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_zero_speed_a(dsa, vel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingAcceleration(double acc, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_acceleration_a(dsa, acc, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingFollowingLimit(double win, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_following_limit_a(dsa, win, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_current_limit_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomeOffset(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_home_offset_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingFixedMvt(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_fixed_mvt_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingSwitchMvt(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_switch_mvt_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingIndexMvt(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_index_mvt_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingFineTuningMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_fine_tuning_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setHomingFineTuningValue(double phase, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_homing_fine_tuning_value_a(dsa, phase, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMotorPhaseCorrection(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_motor_phase_correction_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSoftwareCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_software_current_limit_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setDriveControlMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_drive_control_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setDisplayMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_display_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderInversion(double invert, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_inversion_a(dsa, invert, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setPdrStepValue(double step, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_pdr_step_value_a(dsa, step, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderPhase1Offset(double offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_phase_1_offset_a(dsa, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderPhase2Offset(double offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_phase_2_offset_a(dsa, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderPhase1Factor(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_phase_1_factor_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderPhase2Factor(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_phase_2_factor_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderPhase3Offset(double offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_phase_3_offset_a(dsa, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderIndexDistance(double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_index_distance_a(dsa, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEncoderPhase3Factor(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_encoder_phase_3_factor_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_proportional_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_integrator_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_output_filter_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_current_limit_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLI2tCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_i2t_current_limit_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLI2tTimeLimit(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_i2t_time_limit_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCLRegenMode(int mode, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_cl_regen_mode_a(dsa, mode, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitMode(int typ, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_mode_a(dsa, typ, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitPulseLevel(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_pulse_level_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitMaxCurrent(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_max_current_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitFinalPhase(double cal, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_final_phase_a(dsa, cal, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitTime(double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_time_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitCurrentRate(double cur, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_current_rate_a(dsa, cur, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitPhaseRate(double cal, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_phase_rate_a(dsa, cal, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInitInitialPhase(double cal, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_init_initial_phase_a(dsa, cal, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setDriveFuseChecking(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_drive_fuse_checking_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMotorTempChecking(dword val, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_motor_temp_checking_a(dsa, val, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMonSourceType(int sidx, int typ, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mon_source_type_a(dsa, sidx, typ, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMonSourceIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mon_source_index_a(dsa, sidx, index, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMonDestIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mon_dest_index_a(dsa, sidx, index, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMonOffset(int sidx, long offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mon_offset_a(dsa, sidx, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMonGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mon_gain_a(dsa, sidx, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXAnalogOffset(int sidx, double offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_analog_offset_a(dsa, sidx, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXAnalogGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_analog_gain_a(dsa, sidx, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSyncroInputMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_syncro_input_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSyncroInputValue(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_syncro_input_value_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSyncroOutputMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_syncro_output_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSyncroOutputValue(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_syncro_output_value_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setSyncroStartTimeout(int tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_syncro_start_timeout_a(dsa, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_digital_output_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_digital_output_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXAnalogOutput1(double out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_analog_output_1_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXAnalogOutput2(double out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_analog_output_2_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXAnalogOutput3(double out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_analog_output_3_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setXAnalogOutput4(double out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_x_analog_output_4_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setAnalogOutput(double out, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_analog_output_a(dsa, out, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInterruptMask1(int sidx, dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_interrupt_mask_1_a(dsa, sidx, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setInterruptMask2(int sidx, dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_interrupt_mask_2_a(dsa, sidx, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTriggerIrqMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trigger_irq_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTriggerIOMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trigger_io_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTriggerMapOffset(int offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trigger_map_offset_a(dsa, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTriggerMapSize(int size, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_trigger_map_size_a(dsa, size, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRealtimeEnabledGlobal(int enable, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_realtime_enabled_global_a(dsa, enable, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRealtimeValidMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_realtime_valid_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRealtimeEnabledMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_realtime_enabled_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setRealtimePendingMask(dword mask, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_realtime_pending_mask_a(dsa, mask, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEblBaudrate(long baud, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ebl_baudrate_a(dsa, baud, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setIndirectAxisNumber(int axis, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_indirect_axis_number_a(dsa, axis, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setIndirectRegisterIdx(int idx, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_indirect_register_idx_a(dsa, idx, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setIndirectRegisterSidx(int sidx, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_indirect_register_sidx_a(dsa, sidx, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setConcatenatedMvt(int concat, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_concatenated_mvt_a(dsa, concat, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setProfileType(int sidx, int typ, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_profile_type_a(dsa, sidx, typ, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMvtLktNumber(int sidx, int number, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mvt_lkt_number_a(dsa, sidx, number, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMvtLktTime(int sidx, double time, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_mvt_lkt_time_a(dsa, sidx, time, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCameValue(double factor, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_came_value_a(dsa, factor, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setBrakeDeceleration(double dec, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_brake_deceleration_a(dsa, dec, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setTargetPosition(int sidx, double pos, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_target_position_a(dsa, sidx, pos, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setProfileVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_profile_velocity_a(dsa, sidx, vel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setProfileAcceleration(int sidx, double acc, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_profile_acceleration_a(dsa, sidx, acc, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setJerkTime(int sidx, double tim, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_jerk_time_a(dsa, sidx, tim, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setProfileDeceleration(int sidx, double dec, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_profile_deceleration_a(dsa, sidx, dec, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setEndVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_end_velocity_a(dsa, sidx, vel, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCtrlSourceType(int typ, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ctrl_source_type_a(dsa, typ, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCtrlSourceIndex(int index, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ctrl_source_index_a(dsa, index, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCtrlShiftFactor(int shift, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ctrl_shift_factor_a(dsa, shift, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCtrlOffset(long offset, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ctrl_offset_a(dsa, offset, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setCtrlGain(double gain, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_ctrl_gain_a(dsa, gain, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void setMotorKTFactor(double kt, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_set_motor_kt_factor_a(dsa, kt, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* register getter - synchronous
|
|
|
*/
|
|
|
protected:
|
|
|
double getPLProportionalGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_proportional_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getPLProportionalGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_proportional_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getPLSpeedFeedbackGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_speed_feedback_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getPLSpeedFeedbackGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_speed_feedback_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getPLForceFeedbackGain1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_1_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getPLForceFeedbackGain1(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_1_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getPLIntegratorGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_integrator_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getPLIntegratorGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_integrator_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getPLAntiWindupGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_anti_windup_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getPLAntiWindupGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_anti_windup_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getPLIntegratorLimitation(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double limit;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_integrator_limitation_s(dsa, &limit, kind, timeout));
|
|
|
return limit;
|
|
|
}
|
|
|
void getPLIntegratorLimitation(double *limit, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_integrator_limitation_s(dsa, limit, kind, timeout));
|
|
|
}
|
|
|
int getPLIntegratorMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_integrator_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getPLIntegratorMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_integrator_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
double getPLSpeedFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_speed_filter_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getPLSpeedFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_speed_filter_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
double getPLOutputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_output_filter_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getPLOutputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_output_filter_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
double getCLInputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_input_filter_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getCLInputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_input_filter_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
double getTtlSpecialFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ttl_special_filter_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getTtlSpecialFilter(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ttl_special_filter_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getPLForceFeedbackGain2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_2_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getPLForceFeedbackGain2(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_2_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getPLSpeedFeedfwdGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_speed_feedfwd_gain_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getPLSpeedFeedfwdGain(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_speed_feedfwd_gain_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getPLAccFeedforwardGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pl_acc_feedforward_gain_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getPLAccFeedforwardGain(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pl_acc_feedforward_gain_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getCLPhaseAdvanceFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_phase_advance_factor_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getCLPhaseAdvanceFactor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_phase_advance_factor_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getAprInputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double time;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_apr_input_filter_s(dsa, &time, kind, timeout));
|
|
|
return time;
|
|
|
}
|
|
|
void getAprInputFilter(double *time, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_apr_input_filter_s(dsa, time, kind, timeout));
|
|
|
}
|
|
|
double getCLPhaseAdvanceShift(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double shift;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_phase_advance_shift_s(dsa, &shift, kind, timeout));
|
|
|
return shift;
|
|
|
}
|
|
|
void getCLPhaseAdvanceShift(double *shift, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_phase_advance_shift_s(dsa, shift, kind, timeout));
|
|
|
}
|
|
|
double getMinPositionRangeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_min_position_range_limit_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getMinPositionRangeLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_min_position_range_limit_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getMaxPositionRangeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_max_position_range_limit_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getMaxPositionRangeLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_max_position_range_limit_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getMaxProfileVelocity(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_max_profile_velocity_s(dsa, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getMaxProfileVelocity(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_max_profile_velocity_s(dsa, vel, kind, timeout));
|
|
|
}
|
|
|
double getMaxAcceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double acc;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_max_acceleration_s(dsa, &acc, kind, timeout));
|
|
|
return acc;
|
|
|
}
|
|
|
void getMaxAcceleration(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_max_acceleration_s(dsa, acc, kind, timeout));
|
|
|
}
|
|
|
double getFollowingErrorWindow(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_following_error_window_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getFollowingErrorWindow(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_following_error_window_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getVelocityErrorLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_velocity_error_limit_s(dsa, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getVelocityErrorLimit(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_velocity_error_limit_s(dsa, vel, kind, timeout));
|
|
|
}
|
|
|
int getSwitchLimitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_switch_limit_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getSwitchLimitMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_switch_limit_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
int getEnableInputMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_enable_input_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getEnableInputMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_enable_input_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
double getMinSoftPositionLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_min_soft_position_limit_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getMinSoftPositionLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_min_soft_position_limit_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getMaxSoftPositionLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_max_soft_position_limit_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getMaxSoftPositionLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_max_soft_position_limit_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
dword getProfileLimitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword flags;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_profile_limit_mode_s(dsa, &flags, kind, timeout));
|
|
|
return flags;
|
|
|
}
|
|
|
void getProfileLimitMode(dword *flags, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_profile_limit_mode_s(dsa, flags, kind, timeout));
|
|
|
}
|
|
|
dword getIOErrorEventMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_io_error_event_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getIOErrorEventMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_io_error_event_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
double getPositionWindowTime(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_position_window_time_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getPositionWindowTime(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_position_window_time_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
double getPositionWindow(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double win;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_position_window_s(dsa, &win, kind, timeout));
|
|
|
return win;
|
|
|
}
|
|
|
void getPositionWindow(double *win, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_position_window_s(dsa, win, kind, timeout));
|
|
|
}
|
|
|
int getHomingMethod(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_method_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getHomingMethod(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_method_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
double getHomingZeroSpeed(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_zero_speed_s(dsa, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getHomingZeroSpeed(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_zero_speed_s(dsa, vel, kind, timeout));
|
|
|
}
|
|
|
double getHomingAcceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double acc;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_acceleration_s(dsa, &acc, kind, timeout));
|
|
|
return acc;
|
|
|
}
|
|
|
void getHomingAcceleration(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_acceleration_s(dsa, acc, kind, timeout));
|
|
|
}
|
|
|
double getHomingFollowingLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double win;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_following_limit_s(dsa, &win, kind, timeout));
|
|
|
return win;
|
|
|
}
|
|
|
void getHomingFollowingLimit(double *win, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_following_limit_s(dsa, win, kind, timeout));
|
|
|
}
|
|
|
double getHomingCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_current_limit_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getHomingCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_current_limit_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getHomeOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_home_offset_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getHomeOffset(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_home_offset_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getHomingFixedMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_fixed_mvt_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getHomingFixedMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_fixed_mvt_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getHomingSwitchMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_switch_mvt_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getHomingSwitchMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_switch_mvt_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getHomingIndexMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_index_mvt_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getHomingIndexMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_index_mvt_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
int getHomingFineTuningMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getHomingFineTuningMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
double getHomingFineTuningValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double phase;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_value_s(dsa, &phase, kind, timeout));
|
|
|
return phase;
|
|
|
}
|
|
|
void getHomingFineTuningValue(double *phase, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_value_s(dsa, phase, kind, timeout));
|
|
|
}
|
|
|
int getMotorPhaseCorrection(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_motor_phase_correction_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getMotorPhaseCorrection(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_motor_phase_correction_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
double getSoftwareCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_software_current_limit_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getSoftwareCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_software_current_limit_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
int getDriveControlMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_control_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getDriveControlMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_control_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
int getDisplayMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_display_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getDisplayMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_display_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
double getEncoderInversion(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double invert;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_inversion_s(dsa, &invert, kind, timeout));
|
|
|
return invert;
|
|
|
}
|
|
|
void getEncoderInversion(double *invert, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_inversion_s(dsa, invert, kind, timeout));
|
|
|
}
|
|
|
double getPdrStepValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double step;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_pdr_step_value_s(dsa, &step, kind, timeout));
|
|
|
return step;
|
|
|
}
|
|
|
void getPdrStepValue(double *step, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_pdr_step_value_s(dsa, step, kind, timeout));
|
|
|
}
|
|
|
double getEncoderPhase1Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_phase_1_offset_s(dsa, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getEncoderPhase1Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_phase_1_offset_s(dsa, offset, kind, timeout));
|
|
|
}
|
|
|
double getEncoderPhase2Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_phase_2_offset_s(dsa, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getEncoderPhase2Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_phase_2_offset_s(dsa, offset, kind, timeout));
|
|
|
}
|
|
|
double getEncoderPhase1Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_phase_1_factor_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getEncoderPhase1Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_phase_1_factor_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getEncoderPhase2Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_phase_2_factor_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getEncoderPhase2Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_phase_2_factor_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getEncoderPhase3Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_phase_3_offset_s(dsa, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getEncoderPhase3Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_phase_3_offset_s(dsa, offset, kind, timeout));
|
|
|
}
|
|
|
double getEncoderIndexDistance(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_index_distance_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getEncoderIndexDistance(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_index_distance_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getEncoderPhase3Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_phase_3_factor_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getEncoderPhase3Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_phase_3_factor_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getCLProportionalGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_proportional_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getCLProportionalGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_proportional_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getCLIntegratorGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_integrator_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getCLIntegratorGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_integrator_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getCLOutputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_output_filter_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getCLOutputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_output_filter_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
double getCLCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_current_limit_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_current_limit_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getCLI2tCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_i2t_current_limit_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLI2tCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_i2t_current_limit_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getCLI2tTimeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_i2t_time_limit_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getCLI2tTimeLimit(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_i2t_time_limit_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
int getCLRegenMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int mode;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_regen_mode_s(dsa, &mode, kind, timeout));
|
|
|
return mode;
|
|
|
}
|
|
|
void getCLRegenMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_regen_mode_s(dsa, mode, kind, timeout));
|
|
|
}
|
|
|
int getInitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int typ;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_mode_s(dsa, &typ, kind, timeout));
|
|
|
return typ;
|
|
|
}
|
|
|
void getInitMode(int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_mode_s(dsa, typ, kind, timeout));
|
|
|
}
|
|
|
double getInitPulseLevel(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_pulse_level_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getInitPulseLevel(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_pulse_level_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getInitMaxCurrent(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_max_current_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getInitMaxCurrent(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_max_current_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getInitFinalPhase(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cal;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_final_phase_s(dsa, &cal, kind, timeout));
|
|
|
return cal;
|
|
|
}
|
|
|
void getInitFinalPhase(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_final_phase_s(dsa, cal, kind, timeout));
|
|
|
}
|
|
|
double getInitTime(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_time_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getInitTime(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_time_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
double getInitCurrentRate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_current_rate_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getInitCurrentRate(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_current_rate_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getInitPhaseRate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cal;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_phase_rate_s(dsa, &cal, kind, timeout));
|
|
|
return cal;
|
|
|
}
|
|
|
void getInitPhaseRate(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_phase_rate_s(dsa, cal, kind, timeout));
|
|
|
}
|
|
|
double getInitInitialPhase(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cal;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_init_initial_phase_s(dsa, &cal, kind, timeout));
|
|
|
return cal;
|
|
|
}
|
|
|
void getInitInitialPhase(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_init_initial_phase_s(dsa, cal, kind, timeout));
|
|
|
}
|
|
|
dword getDriveFuseChecking(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_fuse_checking_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getDriveFuseChecking(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_fuse_checking_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getMotorTempChecking(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_motor_temp_checking_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getMotorTempChecking(dword *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_motor_temp_checking_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
int getMonSourceType(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int typ;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mon_source_type_s(dsa, sidx, &typ, kind, timeout));
|
|
|
return typ;
|
|
|
}
|
|
|
void getMonSourceType(int sidx, int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mon_source_type_s(dsa, sidx, typ, kind, timeout));
|
|
|
}
|
|
|
int getMonSourceIndex(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int index;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mon_source_index_s(dsa, sidx, &index, kind, timeout));
|
|
|
return index;
|
|
|
}
|
|
|
void getMonSourceIndex(int sidx, int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mon_source_index_s(dsa, sidx, index, kind, timeout));
|
|
|
}
|
|
|
int getMonDestIndex(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int index;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mon_dest_index_s(dsa, sidx, &index, kind, timeout));
|
|
|
return index;
|
|
|
}
|
|
|
void getMonDestIndex(int sidx, int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mon_dest_index_s(dsa, sidx, index, kind, timeout));
|
|
|
}
|
|
|
long getMonOffset(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
long offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mon_offset_s(dsa, sidx, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getMonOffset(int sidx, long *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mon_offset_s(dsa, sidx, offset, kind, timeout));
|
|
|
}
|
|
|
double getMonGain(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mon_gain_s(dsa, sidx, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getMonGain(int sidx, double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mon_gain_s(dsa, sidx, gain, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogOffset(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_offset_s(dsa, sidx, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getXAnalogOffset(int sidx, double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_offset_s(dsa, sidx, offset, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogGain(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_gain_s(dsa, sidx, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getXAnalogGain(int sidx, double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_gain_s(dsa, sidx, gain, kind, timeout));
|
|
|
}
|
|
|
dword getSyncroInputMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_syncro_input_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getSyncroInputMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_syncro_input_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getSyncroInputValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_syncro_input_value_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getSyncroInputValue(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_syncro_input_value_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getSyncroOutputMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_syncro_output_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getSyncroOutputMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_syncro_output_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getSyncroOutputValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_syncro_output_value_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getSyncroOutputValue(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_syncro_output_value_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
int getSyncroStartTimeout(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_syncro_start_timeout_s(dsa, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getSyncroStartTimeout(int *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_syncro_start_timeout_s(dsa, tim, kind, timeout));
|
|
|
}
|
|
|
dword getDigitalOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_digital_output_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getDigitalOutput(dword *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_digital_output_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
dword getXDigitalOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_digital_output_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getXDigitalOutput(dword *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_digital_output_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogOutput1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_output_1_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getXAnalogOutput1(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_output_1_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogOutput2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_output_2_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getXAnalogOutput2(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_output_2_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogOutput3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_output_3_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getXAnalogOutput3(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_output_3_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogOutput4(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_output_4_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getXAnalogOutput4(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_output_4_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
double getAnalogOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double out;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_analog_output_s(dsa, &out, kind, timeout));
|
|
|
return out;
|
|
|
}
|
|
|
void getAnalogOutput(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_analog_output_s(dsa, out, kind, timeout));
|
|
|
}
|
|
|
dword getInterruptMask1(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_interrupt_mask_1_s(dsa, sidx, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getInterruptMask1(int sidx, dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_interrupt_mask_1_s(dsa, sidx, mask, kind, timeout));
|
|
|
}
|
|
|
dword getInterruptMask2(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_interrupt_mask_2_s(dsa, sidx, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getInterruptMask2(int sidx, dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_interrupt_mask_2_s(dsa, sidx, mask, kind, timeout));
|
|
|
}
|
|
|
dword getTriggerIrqMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_trigger_irq_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getTriggerIrqMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_trigger_irq_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getTriggerIOMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_trigger_io_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getTriggerIOMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_trigger_io_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
int getTriggerMapOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_trigger_map_offset_s(dsa, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getTriggerMapOffset(int *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_trigger_map_offset_s(dsa, offset, kind, timeout));
|
|
|
}
|
|
|
int getTriggerMapSize(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int size;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_trigger_map_size_s(dsa, &size, kind, timeout));
|
|
|
return size;
|
|
|
}
|
|
|
void getTriggerMapSize(int *size, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_trigger_map_size_s(dsa, size, kind, timeout));
|
|
|
}
|
|
|
int getRealtimeEnabledGlobal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int enable;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_realtime_enabled_global_s(dsa, &enable, kind, timeout));
|
|
|
return enable;
|
|
|
}
|
|
|
void getRealtimeEnabledGlobal(int *enable, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_realtime_enabled_global_s(dsa, enable, kind, timeout));
|
|
|
}
|
|
|
dword getRealtimeValidMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_realtime_valid_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getRealtimeValidMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_realtime_valid_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getRealtimeEnabledMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_realtime_enabled_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getRealtimeEnabledMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_realtime_enabled_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getRealtimePendingMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_realtime_pending_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getRealtimePendingMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_realtime_pending_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
long getEblBaudrate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
long baud;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ebl_baudrate_s(dsa, &baud, kind, timeout));
|
|
|
return baud;
|
|
|
}
|
|
|
void getEblBaudrate(long *baud, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ebl_baudrate_s(dsa, baud, kind, timeout));
|
|
|
}
|
|
|
int getIndirectAxisNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int axis;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_indirect_axis_number_s(dsa, &axis, kind, timeout));
|
|
|
return axis;
|
|
|
}
|
|
|
void getIndirectAxisNumber(int *axis, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_indirect_axis_number_s(dsa, axis, kind, timeout));
|
|
|
}
|
|
|
int getIndirectRegisterIdx(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int idx;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_indirect_register_idx_s(dsa, &idx, kind, timeout));
|
|
|
return idx;
|
|
|
}
|
|
|
void getIndirectRegisterIdx(int *idx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_indirect_register_idx_s(dsa, idx, kind, timeout));
|
|
|
}
|
|
|
int getIndirectRegisterSidx(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int sidx;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_indirect_register_sidx_s(dsa, &sidx, kind, timeout));
|
|
|
return sidx;
|
|
|
}
|
|
|
void getIndirectRegisterSidx(int *sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_indirect_register_sidx_s(dsa, sidx, kind, timeout));
|
|
|
}
|
|
|
int getConcatenatedMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int concat;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_concatenated_mvt_s(dsa, &concat, kind, timeout));
|
|
|
return concat;
|
|
|
}
|
|
|
void getConcatenatedMvt(int *concat, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_concatenated_mvt_s(dsa, concat, kind, timeout));
|
|
|
}
|
|
|
int getProfileType(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int typ;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_profile_type_s(dsa, sidx, &typ, kind, timeout));
|
|
|
return typ;
|
|
|
}
|
|
|
void getProfileType(int sidx, int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_profile_type_s(dsa, sidx, typ, kind, timeout));
|
|
|
}
|
|
|
int getMvtLktNumber(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int number;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mvt_lkt_number_s(dsa, sidx, &number, kind, timeout));
|
|
|
return number;
|
|
|
}
|
|
|
void getMvtLktNumber(int sidx, int *number, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mvt_lkt_number_s(dsa, sidx, number, kind, timeout));
|
|
|
}
|
|
|
double getMvtLktTime(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double time;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_mvt_lkt_time_s(dsa, sidx, &time, kind, timeout));
|
|
|
return time;
|
|
|
}
|
|
|
void getMvtLktTime(int sidx, double *time, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_mvt_lkt_time_s(dsa, sidx, time, kind, timeout));
|
|
|
}
|
|
|
double getCameValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double factor;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_came_value_s(dsa, &factor, kind, timeout));
|
|
|
return factor;
|
|
|
}
|
|
|
void getCameValue(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_came_value_s(dsa, factor, kind, timeout));
|
|
|
}
|
|
|
double getBrakeDeceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double dec;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_brake_deceleration_s(dsa, &dec, kind, timeout));
|
|
|
return dec;
|
|
|
}
|
|
|
void getBrakeDeceleration(double *dec, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_brake_deceleration_s(dsa, dec, kind, timeout));
|
|
|
}
|
|
|
double getTargetPosition(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_target_position_s(dsa, sidx, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getTargetPosition(int sidx, double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_target_position_s(dsa, sidx, pos, kind, timeout));
|
|
|
}
|
|
|
double getProfileVelocity(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_profile_velocity_s(dsa, sidx, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getProfileVelocity(int sidx, double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_profile_velocity_s(dsa, sidx, vel, kind, timeout));
|
|
|
}
|
|
|
double getProfileAcceleration(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double acc;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_profile_acceleration_s(dsa, sidx, &acc, kind, timeout));
|
|
|
return acc;
|
|
|
}
|
|
|
void getProfileAcceleration(int sidx, double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_profile_acceleration_s(dsa, sidx, acc, kind, timeout));
|
|
|
}
|
|
|
double getJerkTime(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double tim;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_jerk_time_s(dsa, sidx, &tim, kind, timeout));
|
|
|
return tim;
|
|
|
}
|
|
|
void getJerkTime(int sidx, double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_jerk_time_s(dsa, sidx, tim, kind, timeout));
|
|
|
}
|
|
|
double getProfileDeceleration(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double dec;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_profile_deceleration_s(dsa, sidx, &dec, kind, timeout));
|
|
|
return dec;
|
|
|
}
|
|
|
void getProfileDeceleration(int sidx, double *dec, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_profile_deceleration_s(dsa, sidx, dec, kind, timeout));
|
|
|
}
|
|
|
double getEndVelocity(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_end_velocity_s(dsa, sidx, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getEndVelocity(int sidx, double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_end_velocity_s(dsa, sidx, vel, kind, timeout));
|
|
|
}
|
|
|
int getCtrlSourceType(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int typ;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ctrl_source_type_s(dsa, &typ, kind, timeout));
|
|
|
return typ;
|
|
|
}
|
|
|
void getCtrlSourceType(int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ctrl_source_type_s(dsa, typ, kind, timeout));
|
|
|
}
|
|
|
int getCtrlSourceIndex(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int index;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ctrl_source_index_s(dsa, &index, kind, timeout));
|
|
|
return index;
|
|
|
}
|
|
|
void getCtrlSourceIndex(int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ctrl_source_index_s(dsa, index, kind, timeout));
|
|
|
}
|
|
|
int getCtrlShiftFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int shift;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ctrl_shift_factor_s(dsa, &shift, kind, timeout));
|
|
|
return shift;
|
|
|
}
|
|
|
void getCtrlShiftFactor(int *shift, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ctrl_shift_factor_s(dsa, shift, kind, timeout));
|
|
|
}
|
|
|
long getCtrlOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
long offset;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ctrl_offset_s(dsa, &offset, kind, timeout));
|
|
|
return offset;
|
|
|
}
|
|
|
void getCtrlOffset(long *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ctrl_offset_s(dsa, offset, kind, timeout));
|
|
|
}
|
|
|
double getCtrlGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double gain;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ctrl_gain_s(dsa, &gain, kind, timeout));
|
|
|
return gain;
|
|
|
}
|
|
|
void getCtrlGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ctrl_gain_s(dsa, gain, kind, timeout));
|
|
|
}
|
|
|
double getMotorKTFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double kt;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_motor_kt_factor_s(dsa, &kt, kind, timeout));
|
|
|
return kt;
|
|
|
}
|
|
|
void getMotorKTFactor(double *kt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_motor_kt_factor_s(dsa, kt, kind, timeout));
|
|
|
}
|
|
|
double getPositionCtrlError(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double err;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_position_ctrl_error_s(dsa, &err, kind, timeout));
|
|
|
return err;
|
|
|
}
|
|
|
void getPositionCtrlError(double *err, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_position_ctrl_error_s(dsa, err, kind, timeout));
|
|
|
}
|
|
|
double getPositionMaxError(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double err;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_position_max_error_s(dsa, &err, kind, timeout));
|
|
|
return err;
|
|
|
}
|
|
|
void getPositionMaxError(double *err, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_position_max_error_s(dsa, err, kind, timeout));
|
|
|
}
|
|
|
double getPositionDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_position_demand_value_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getPositionDemandValue(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_position_demand_value_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getPositionActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double pos;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_position_actual_value_s(dsa, &pos, kind, timeout));
|
|
|
return pos;
|
|
|
}
|
|
|
void getPositionActualValue(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_position_actual_value_s(dsa, pos, kind, timeout));
|
|
|
}
|
|
|
double getVelocityDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_velocity_demand_value_s(dsa, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getVelocityDemandValue(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_velocity_demand_value_s(dsa, vel, kind, timeout));
|
|
|
}
|
|
|
double getVelocityActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double vel;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_velocity_actual_value_s(dsa, &vel, kind, timeout));
|
|
|
return vel;
|
|
|
}
|
|
|
void getVelocityActualValue(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_velocity_actual_value_s(dsa, vel, kind, timeout));
|
|
|
}
|
|
|
double getAccDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double acc;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_acc_demand_value_s(dsa, &acc, kind, timeout));
|
|
|
return acc;
|
|
|
}
|
|
|
void getAccDemandValue(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_acc_demand_value_s(dsa, acc, kind, timeout));
|
|
|
}
|
|
|
double getAccActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double acc;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_acc_actual_value_s(dsa, &acc, kind, timeout));
|
|
|
return acc;
|
|
|
}
|
|
|
void getAccActualValue(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_acc_actual_value_s(dsa, acc, kind, timeout));
|
|
|
}
|
|
|
double getRefDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double ref;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ref_demand_value_s(dsa, &ref, kind, timeout));
|
|
|
return ref;
|
|
|
}
|
|
|
void getRefDemandValue(double *ref, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ref_demand_value_s(dsa, ref, kind, timeout));
|
|
|
}
|
|
|
dword getDriveControlMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_control_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getDriveControlMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_control_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
double getCLCurrentPhase1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_current_phase_1_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLCurrentPhase1(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_1_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getCLCurrentPhase2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_current_phase_2_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLCurrentPhase2(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_2_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getCLCurrentPhase3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_current_phase_3_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLCurrentPhase3(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_3_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getCLLktPhase1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double lkt;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_1_s(dsa, &lkt, kind, timeout));
|
|
|
return lkt;
|
|
|
}
|
|
|
void getCLLktPhase1(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_1_s(dsa, lkt, kind, timeout));
|
|
|
}
|
|
|
double getCLLktPhase2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double lkt;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_2_s(dsa, &lkt, kind, timeout));
|
|
|
return lkt;
|
|
|
}
|
|
|
void getCLLktPhase2(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_2_s(dsa, lkt, kind, timeout));
|
|
|
}
|
|
|
double getCLLktPhase3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double lkt;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_3_s(dsa, &lkt, kind, timeout));
|
|
|
return lkt;
|
|
|
}
|
|
|
void getCLLktPhase3(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_3_s(dsa, lkt, kind, timeout));
|
|
|
}
|
|
|
double getCLDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_demand_value_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLDemandValue(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_demand_value_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getCLActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double cur;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_actual_value_s(dsa, &cur, kind, timeout));
|
|
|
return cur;
|
|
|
}
|
|
|
void getCLActualValue(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_actual_value_s(dsa, cur, kind, timeout));
|
|
|
}
|
|
|
double getEncoderSineSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_sine_signal_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getEncoderSineSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_sine_signal_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
double getEncoderCosineSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_cosine_signal_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getEncoderCosineSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_cosine_signal_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
double getEncoderIndexSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_index_signal_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getEncoderIndexSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_index_signal_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
double getEncoderHall1Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_hall_1_signal_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getEncoderHall1Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_hall_1_signal_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
double getEncoderHall2Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_hall_2_signal_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getEncoderHall2Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_hall_2_signal_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
double getEncoderHall3Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_hall_3_signal_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getEncoderHall3Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_hall_3_signal_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
dword getEncoderHallDigSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_encoder_hall_dig_signal_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getEncoderHallDigSignal(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_encoder_hall_dig_signal_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getDigitalInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_digital_input_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getDigitalInput(dword *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_digital_input_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
double getAnalogInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_analog_input_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getAnalogInput(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_analog_input_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
dword getXDigitalInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_digital_input_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getXDigitalInput(dword *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_digital_input_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogInput1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_input_1_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getXAnalogInput1(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_input_1_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogInput2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_input_2_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getXAnalogInput2(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_input_2_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogInput3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_input_3_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getXAnalogInput3(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_input_3_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
double getXAnalogInput4(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double inp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_x_analog_input_4_s(dsa, &inp, kind, timeout));
|
|
|
return inp;
|
|
|
}
|
|
|
void getXAnalogInput4(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_x_analog_input_4_s(dsa, inp, kind, timeout));
|
|
|
}
|
|
|
dword getDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_status_1_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_status_1_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_status_2_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_status_2_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
double getCLI2tValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double val;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_cl_i2t_value_s(dsa, &val, kind, timeout));
|
|
|
return val;
|
|
|
}
|
|
|
void getCLI2tValue(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_cl_i2t_value_s(dsa, val, kind, timeout));
|
|
|
}
|
|
|
int getAxisNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int num;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_axis_number_s(dsa, &num, kind, timeout));
|
|
|
return num;
|
|
|
}
|
|
|
void getAxisNumber(int *num, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_axis_number_s(dsa, num, kind, timeout));
|
|
|
}
|
|
|
int getDaisyChainNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int num;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_daisy_chain_number_s(dsa, &num, kind, timeout));
|
|
|
return num;
|
|
|
}
|
|
|
void getDaisyChainNumber(int *num, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_daisy_chain_number_s(dsa, num, kind, timeout));
|
|
|
}
|
|
|
double getDriveTemperature(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
double temp;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_temperature_s(dsa, &temp, kind, timeout));
|
|
|
return temp;
|
|
|
}
|
|
|
void getDriveTemperature(double *temp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_temperature_s(dsa, temp, kind, timeout));
|
|
|
}
|
|
|
dword getDriveMaskValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword str;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_mask_value_s(dsa, &str, kind, timeout));
|
|
|
return str;
|
|
|
}
|
|
|
void getDriveMaskValue(dword *str, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_mask_value_s(dsa, str, kind, timeout));
|
|
|
}
|
|
|
dword getDriveDisplay(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword str;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_display_s(dsa, sidx, &str, kind, timeout));
|
|
|
return str;
|
|
|
}
|
|
|
void getDriveDisplay(int sidx, dword *str, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_display_s(dsa, sidx, str, kind, timeout));
|
|
|
}
|
|
|
long getDriveSequenceLine(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
long line;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_sequence_line_s(dsa, &line, kind, timeout));
|
|
|
return line;
|
|
|
}
|
|
|
void getDriveSequenceLine(long *line, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_sequence_line_s(dsa, line, kind, timeout));
|
|
|
}
|
|
|
dword getDriveFuseStatus(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_drive_fuse_status_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getDriveFuseStatus(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_drive_fuse_status_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getIrqDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_irq_drive_status_1_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getIrqDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_irq_drive_status_1_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getIrqDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_irq_drive_status_2_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getIrqDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_irq_drive_status_2_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getAckDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ack_drive_status_1_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getAckDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ack_drive_status_1_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getAckDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_ack_drive_status_2_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getAckDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_ack_drive_status_2_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getIrqPendingAxisMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword mask;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_irq_pending_axis_mask_s(dsa, &mask, kind, timeout));
|
|
|
return mask;
|
|
|
}
|
|
|
void getIrqPendingAxisMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_irq_pending_axis_mask_s(dsa, mask, kind, timeout));
|
|
|
}
|
|
|
dword getCanFeedback1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword val1;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_can_feedback_1_s(dsa, &val1, kind, timeout));
|
|
|
return val1;
|
|
|
}
|
|
|
void getCanFeedback1(dword *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_can_feedback_1_s(dsa, val1, kind, timeout));
|
|
|
}
|
|
|
dword getCanFeedback2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
dword val1;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_can_feedback_2_s(dsa, &val1, kind, timeout));
|
|
|
return val1;
|
|
|
}
|
|
|
void getCanFeedback2(dword *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_can_feedback_2_s(dsa, val1, kind, timeout));
|
|
|
}
|
|
|
int getNbAvailableSlot(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
int nb_free;
|
|
|
ERRTRANS();
|
|
|
ERRCHK(dsa_get_nb_available_slots_s(dsa, &nb_free, kind, timeout));
|
|
|
return nb_free;
|
|
|
}
|
|
|
void getNbAvailableSlot(int *nb_free, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {
|
|
|
ERRCHK(dsa_get_nb_available_slots_s(dsa, nb_free, kind, timeout));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* register getter - asynchronous
|
|
|
*/
|
|
|
protected:
|
|
|
void getPLProportionalGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_proportional_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLProportionalGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_proportional_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLSpeedFeedbackGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_speed_feedback_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLSpeedFeedbackGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_speed_feedback_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLForceFeedbackGain1(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_1_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLForceFeedbackGain1(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_1_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLIntegratorGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_integrator_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLIntegratorGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_integrator_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLAntiWindupGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_anti_windup_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLAntiWindupGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_anti_windup_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLIntegratorLimitation(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_integrator_limitation_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLIntegratorLimitation(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_integrator_limitation_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLIntegratorMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_integrator_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLIntegratorMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_integrator_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLSpeedFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_speed_filter_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLSpeedFilter(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_speed_filter_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLOutputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_output_filter_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLOutputFilter(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_output_filter_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLInputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_input_filter_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLInputFilter(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_input_filter_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTtlSpecialFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ttl_special_filter_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTtlSpecialFilter(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ttl_special_filter_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLForceFeedbackGain2(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_2_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLForceFeedbackGain2(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_force_feedback_gain_2_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLSpeedFeedfwdGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_speed_feedfwd_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLSpeedFeedfwdGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_speed_feedfwd_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLAccFeedforwardGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_acc_feedforward_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPLAccFeedforwardGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pl_acc_feedforward_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLPhaseAdvanceFactor(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_phase_advance_factor_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLPhaseAdvanceFactor(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_phase_advance_factor_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAprInputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_apr_input_filter_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAprInputFilter(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_apr_input_filter_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLPhaseAdvanceShift(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_phase_advance_shift_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLPhaseAdvanceShift(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_phase_advance_shift_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMinPositionRangeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_min_position_range_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMinPositionRangeLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_min_position_range_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxPositionRangeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_position_range_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxPositionRangeLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_position_range_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxProfileVelocity(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_profile_velocity_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxProfileVelocity(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_profile_velocity_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxAcceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_acceleration_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxAcceleration(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_acceleration_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getFollowingErrorWindow(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_following_error_window_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getFollowingErrorWindow(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_following_error_window_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getVelocityErrorLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_velocity_error_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getVelocityErrorLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_velocity_error_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSwitchLimitMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_switch_limit_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSwitchLimitMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_switch_limit_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEnableInputMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_enable_input_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEnableInputMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_enable_input_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMinSoftPositionLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_min_soft_position_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMinSoftPositionLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_min_soft_position_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxSoftPositionLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_soft_position_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMaxSoftPositionLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_max_soft_position_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileLimitMode(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_limit_mode_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileLimitMode(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_limit_mode_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIOErrorEventMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_io_error_event_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIOErrorEventMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_io_error_event_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionWindowTime(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_window_time_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionWindowTime(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_window_time_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionWindow(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_window_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionWindow(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_window_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingMethod(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_method_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingMethod(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_method_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingZeroSpeed(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_zero_speed_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingZeroSpeed(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_zero_speed_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingAcceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_acceleration_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingAcceleration(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_acceleration_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFollowingLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_following_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFollowingLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_following_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_current_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_current_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomeOffset(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_home_offset_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomeOffset(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_home_offset_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFixedMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_fixed_mvt_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFixedMvt(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_fixed_mvt_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingSwitchMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_switch_mvt_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingSwitchMvt(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_switch_mvt_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingIndexMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_index_mvt_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingIndexMvt(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_index_mvt_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFineTuningMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFineTuningMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFineTuningValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getHomingFineTuningValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_homing_fine_tuning_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMotorPhaseCorrection(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_motor_phase_correction_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMotorPhaseCorrection(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_motor_phase_correction_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSoftwareCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_software_current_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSoftwareCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_software_current_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveControlMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_control_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveControlMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_control_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDisplayMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_display_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDisplayMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_display_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderInversion(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_inversion_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderInversion(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_inversion_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPdrStepValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pdr_step_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPdrStepValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_pdr_step_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase1Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_1_offset_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase1Offset(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_1_offset_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase2Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_2_offset_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase2Offset(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_2_offset_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase1Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_1_factor_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase1Factor(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_1_factor_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase2Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_2_factor_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase2Factor(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_2_factor_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase3Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_3_offset_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase3Offset(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_3_offset_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderIndexDistance(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_index_distance_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderIndexDistance(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_index_distance_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase3Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_3_factor_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderPhase3Factor(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_phase_3_factor_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLProportionalGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_proportional_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLProportionalGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_proportional_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLIntegratorGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_integrator_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLIntegratorGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_integrator_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLOutputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_output_filter_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLOutputFilter(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_output_filter_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLI2tCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_i2t_current_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLI2tCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_i2t_current_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLI2tTimeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_i2t_time_limit_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLI2tTimeLimit(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_i2t_time_limit_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLRegenMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_regen_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLRegenMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_regen_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitMode(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_mode_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitMode(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_mode_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitPulseLevel(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_pulse_level_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitPulseLevel(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_pulse_level_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitMaxCurrent(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_max_current_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitMaxCurrent(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_max_current_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitFinalPhase(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_final_phase_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitFinalPhase(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_final_phase_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitTime(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_time_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitTime(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_time_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitCurrentRate(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_current_rate_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitCurrentRate(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_current_rate_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitPhaseRate(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_phase_rate_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitPhaseRate(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_phase_rate_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitInitialPhase(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_initial_phase_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInitInitialPhase(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_init_initial_phase_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveFuseChecking(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_fuse_checking_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveFuseChecking(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_fuse_checking_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMotorTempChecking(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_motor_temp_checking_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMotorTempChecking(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_motor_temp_checking_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonSourceType(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_source_type_a(dsa, sidx, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonSourceType(int sidx, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_source_type_a(dsa, sidx, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonSourceIndex(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_source_index_a(dsa, sidx, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonSourceIndex(int sidx, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_source_index_a(dsa, sidx, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonDestIndex(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_dest_index_a(dsa, sidx, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonDestIndex(int sidx, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_dest_index_a(dsa, sidx, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonOffset(int sidx, int kind, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_offset_a(dsa, sidx, kind, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonOffset(int sidx, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_offset_a(dsa, sidx, GET_CURRENT, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonGain(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_gain_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMonGain(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mon_gain_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOffset(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_offset_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOffset(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_offset_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogGain(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_gain_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogGain(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_gain_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroInputMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_input_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroInputMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_input_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroInputValue(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_input_value_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroInputValue(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_input_value_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroOutputMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_output_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroOutputMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_output_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroOutputValue(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_output_value_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroOutputValue(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_output_value_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroStartTimeout(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_start_timeout_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getSyncroStartTimeout(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_syncro_start_timeout_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDigitalOutput(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_digital_output_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDigitalOutput(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_digital_output_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXDigitalOutput(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_digital_output_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXDigitalOutput(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_digital_output_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput1(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_1_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput1(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_1_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput2(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_2_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput2(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_2_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput3(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_3_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput3(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_3_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput4(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_4_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogOutput4(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_output_4_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAnalogOutput(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_analog_output_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAnalogOutput(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_analog_output_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInterruptMask1(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_interrupt_mask_1_a(dsa, sidx, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInterruptMask1(int sidx, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_interrupt_mask_1_a(dsa, sidx, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInterruptMask2(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_interrupt_mask_2_a(dsa, sidx, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getInterruptMask2(int sidx, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_interrupt_mask_2_a(dsa, sidx, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerIrqMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_irq_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerIrqMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_irq_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerIOMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_io_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerIOMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_io_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerMapOffset(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_map_offset_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerMapOffset(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_map_offset_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerMapSize(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_map_size_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTriggerMapSize(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_trigger_map_size_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimeEnabledGlobal(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_enabled_global_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimeEnabledGlobal(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_enabled_global_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimeValidMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_valid_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimeValidMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_valid_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimeEnabledMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_enabled_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimeEnabledMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_enabled_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimePendingMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_pending_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRealtimePendingMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_realtime_pending_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEblBaudrate(int kind, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ebl_baudrate_a(dsa, kind, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEblBaudrate(DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ebl_baudrate_a(dsa, GET_CURRENT, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIndirectAxisNumber(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_indirect_axis_number_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIndirectAxisNumber(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_indirect_axis_number_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIndirectRegisterIdx(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_indirect_register_idx_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIndirectRegisterIdx(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_indirect_register_idx_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIndirectRegisterSidx(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_indirect_register_sidx_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIndirectRegisterSidx(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_indirect_register_sidx_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getConcatenatedMvt(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_concatenated_mvt_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getConcatenatedMvt(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_concatenated_mvt_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileType(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_type_a(dsa, sidx, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileType(int sidx, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_type_a(dsa, sidx, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMvtLktNumber(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mvt_lkt_number_a(dsa, sidx, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMvtLktNumber(int sidx, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mvt_lkt_number_a(dsa, sidx, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMvtLktTime(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mvt_lkt_time_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMvtLktTime(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_mvt_lkt_time_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCameValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_came_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCameValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_came_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getBrakeDeceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_brake_deceleration_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getBrakeDeceleration(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_brake_deceleration_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTargetPosition(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_target_position_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getTargetPosition(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_target_position_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileVelocity(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_velocity_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileVelocity(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_velocity_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileAcceleration(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_acceleration_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileAcceleration(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_acceleration_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getJerkTime(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_jerk_time_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getJerkTime(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_jerk_time_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileDeceleration(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_deceleration_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getProfileDeceleration(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_profile_deceleration_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEndVelocity(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_end_velocity_a(dsa, sidx, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEndVelocity(int sidx, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_end_velocity_a(dsa, sidx, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlSourceType(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_source_type_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlSourceType(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_source_type_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlSourceIndex(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_source_index_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlSourceIndex(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_source_index_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlShiftFactor(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_shift_factor_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlShiftFactor(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_shift_factor_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlOffset(int kind, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_offset_a(dsa, kind, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlOffset(DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_offset_a(dsa, GET_CURRENT, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlGain(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_gain_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCtrlGain(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ctrl_gain_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMotorKTFactor(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_motor_kt_factor_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getMotorKTFactor(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_motor_kt_factor_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionCtrlError(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_ctrl_error_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionCtrlError(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_ctrl_error_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionMaxError(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_max_error_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionMaxError(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_max_error_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_demand_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionDemandValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_demand_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_actual_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getPositionActualValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_position_actual_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getVelocityDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_velocity_demand_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getVelocityDemandValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_velocity_demand_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getVelocityActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_velocity_actual_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getVelocityActualValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_velocity_actual_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAccDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_acc_demand_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAccDemandValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_acc_demand_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAccActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_acc_actual_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAccActualValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_acc_actual_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRefDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ref_demand_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getRefDemandValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ref_demand_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveControlMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_control_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveControlMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_control_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentPhase1(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_1_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentPhase1(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_1_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentPhase2(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_2_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentPhase2(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_2_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentPhase3(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_3_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLCurrentPhase3(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_current_phase_3_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLLktPhase1(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_1_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLLktPhase1(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_1_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLLktPhase2(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_2_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLLktPhase2(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_2_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLLktPhase3(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_3_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLLktPhase3(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_lkt_phase_3_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_demand_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLDemandValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_demand_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_actual_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLActualValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_actual_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderSineSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_sine_signal_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderSineSignal(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_sine_signal_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderCosineSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_cosine_signal_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderCosineSignal(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_cosine_signal_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderIndexSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_index_signal_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderIndexSignal(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_index_signal_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHall1Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_1_signal_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHall1Signal(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_1_signal_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHall2Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_2_signal_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHall2Signal(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_2_signal_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHall3Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_3_signal_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHall3Signal(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_3_signal_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHallDigSignal(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_dig_signal_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getEncoderHallDigSignal(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_encoder_hall_dig_signal_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDigitalInput(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_digital_input_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDigitalInput(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_digital_input_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAnalogInput(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_analog_input_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAnalogInput(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_analog_input_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXDigitalInput(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_digital_input_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXDigitalInput(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_digital_input_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput1(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_1_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput1(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_1_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput2(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_2_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput2(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_2_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput3(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_3_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput3(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_3_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput4(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_4_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getXAnalogInput4(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_x_analog_input_4_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_status_1_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveStatus1(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_status_1_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_status_2_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveStatus2(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_status_2_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLI2tValue(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_i2t_value_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCLI2tValue(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_cl_i2t_value_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAxisNumber(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_axis_number_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAxisNumber(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_axis_number_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDaisyChainNumber(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_daisy_chain_number_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDaisyChainNumber(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_daisy_chain_number_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveTemperature(int kind, DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_temperature_a(dsa, kind, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveTemperature(DsaDoubleHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_temperature_a(dsa, GET_CURRENT, (DSA_DOUBLE_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveMaskValue(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_mask_value_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveMaskValue(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_mask_value_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveDisplay(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_display_a(dsa, sidx, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveDisplay(int sidx, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_display_a(dsa, sidx, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveSequenceLine(int kind, DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_sequence_line_a(dsa, kind, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveSequenceLine(DsaLongHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_sequence_line_a(dsa, GET_CURRENT, (DSA_LONG_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveFuseStatus(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_fuse_status_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getDriveFuseStatus(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_drive_fuse_status_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIrqDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_irq_drive_status_1_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIrqDriveStatus1(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_irq_drive_status_1_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIrqDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_irq_drive_status_2_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIrqDriveStatus2(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_irq_drive_status_2_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAckDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ack_drive_status_1_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAckDriveStatus1(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ack_drive_status_1_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAckDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ack_drive_status_2_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getAckDriveStatus2(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_ack_drive_status_2_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIrqPendingAxisMask(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_irq_pending_axis_mask_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getIrqPendingAxisMask(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_irq_pending_axis_mask_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCanFeedback1(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_can_feedback_1_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCanFeedback1(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_can_feedback_1_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCanFeedback2(int kind, DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_can_feedback_2_a(dsa, kind, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getCanFeedback2(DsaDWordHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_can_feedback_2_a(dsa, GET_CURRENT, (DSA_DWORD_HANDLER)handler, param));
|
|
|
}
|
|
|
void getNbAvailableSlot(int kind, DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_nb_available_slots_a(dsa, kind, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
void getNbAvailableSlot(DsaIntHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_get_nb_available_slots_a(dsa, GET_CURRENT, (DSA_INT_HANDLER)handler, param));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDeviceBase Class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDeviceBase: public DsaBase {
|
|
|
friend class Dsa;
|
|
|
|
|
|
/* constructors */
|
|
|
protected:
|
|
|
DsaDeviceBase(void) {}
|
|
|
DsaDeviceBase(DSA_DEVICE_BASE *dev) {
|
|
|
ERRCHK(dsa_share(dev));
|
|
|
dsa = dev;
|
|
|
}
|
|
|
public:
|
|
|
DsaDeviceBase(DsaDeviceBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDeviceBase(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_device_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
|
|
|
/* operators */
|
|
|
public:
|
|
|
DsaDeviceBase operator = (DsaDeviceBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDeviceBase operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_device_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
#ifdef DSA_IMPL_S
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
#ifdef DSA_IMPL_A
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaHandlerDeviceBase class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaHandlerDeviceBase: public DsaDeviceBase {
|
|
|
/* constructors - destructors */
|
|
|
protected:
|
|
|
DsaHandlerDeviceBase(void) { }
|
|
|
DsaHandlerDeviceBase(DsaHandlerDeviceBase &obj) {}
|
|
|
public:
|
|
|
//This destructor has to call dsa_share, because this object is the device object of a asynchronous
|
|
|
//handler, and thus is not constructed => not shared => not destructable by dsabase destructor
|
|
|
//which will be called
|
|
|
//By sharing this object at destruction, we allow the call of the DsaBase destructor
|
|
|
~DsaHandlerDeviceBase(void) {
|
|
|
if (dsa)
|
|
|
ERRCHK(dsa_share(dsa));
|
|
|
}
|
|
|
/* operators */
|
|
|
protected:
|
|
|
DsaHandlerDeviceBase operator = (DsaHandlerDeviceBase &obj) {
|
|
|
return obj;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDevice class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDevice: public DsaBase {
|
|
|
/* constructors */
|
|
|
protected:
|
|
|
DsaDevice(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaDevice(DsaDevice &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDevice(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_device(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
/* operators */
|
|
|
public:
|
|
|
DsaDevice operator = (DsaDevice &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDevice operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_device(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
#ifdef DSA_IMPL_S
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
int getWarningCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getWarningCode(kind, timeout);}
|
|
|
int getErrorCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getErrorCode(kind, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
|
|
|
long getRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegister(typ, idx, sidx, kind, timeout);}
|
|
|
long getRegisterInt32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt32(typ, idx, sidx, kind, timeout);}
|
|
|
eint64 getRegisterInt64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt64(typ, idx, sidx, kind, timeout);}
|
|
|
float getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat32(typ, idx, sidx, kind, timeout);}
|
|
|
double getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat64(typ, idx, sidx, kind, timeout);}
|
|
|
float getFloatRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getFloatRegister(typ, idx, sidx, kind, timeout);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
double getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, timeout);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout = DEF_TIMEOUT) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, timeout);}
|
|
|
DsaStatus waitStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusChange(DsaStatus *mask, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusChange(mask, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
#ifdef DSA_IMPL_A
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void getWarningCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getWarningCode(kind, handler, param);}
|
|
|
void getErrorCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getErrorCode(kind, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void getRegister(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt32(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegisterInt32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt64(int typ, unsigned idx, int sidx, int kind, DsaInt64Handler handler, void *param = NULL) {DsaBase::getRegisterInt64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, DsaFloatHandler handler, void *param = NULL) {DsaBase::getRegisterFloat32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRegisterFloat64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getFloatRegister(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFloatRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, handler, param);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, Dsa2intHandler handler, void *param = NULL) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, handler, param);}
|
|
|
void waitStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusEqual(mask, ref, handler, param);}
|
|
|
void waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void waitStatusChange(DsaStatus *mask, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusChange(mask, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
void open(EtbBus etb, int axis) {DsaBase::open(etb, axis);}
|
|
|
void etcomOpen(EtbBus etb, int axis) {DsaBase::etcomOpen(etb, axis);}
|
|
|
void open(char_cp url) {DsaBase::open(url);}
|
|
|
void open(EtbBus etb, int axis, dword flags) {DsaBase::open(etb, axis, flags);}
|
|
|
void etcomOpen(EtbBus etb, int axis, dword flags) {DsaBase::etcomOpen(etb, axis, flags);}
|
|
|
void reset() {DsaBase::reset();}
|
|
|
void close() {DsaBase::close();}
|
|
|
EtbBus getEtbBus() {return DsaBase::getEtbBus();}
|
|
|
int getEtbAxis() {return DsaBase::getEtbAxis();}
|
|
|
int etcomGetEtbAxis() {return DsaBase::etcomGetEtbAxis();}
|
|
|
bool isOpen() {return DsaBase::isOpen();}
|
|
|
int getMotorTyp() {return DsaBase::getMotorTyp();}
|
|
|
void getErrorText(char_p text, int size, int code) {DsaBase::getErrorText(text, size, code);}
|
|
|
void getWarningText(char_p text, int size, int code) {DsaBase::getWarningText(text, size, code);}
|
|
|
double convertToIso(long inc, int conv) {return DsaBase::convertToIso(inc, conv);}
|
|
|
double convertInt32ToIso(long inc, int conv) {return DsaBase::convertInt32ToIso(inc, conv);}
|
|
|
double convertInt64ToIso(eint64 inc, int conv) {return DsaBase::convertInt64ToIso(inc, conv);}
|
|
|
double convertFloat32ToIso(float inc, int conv) {return DsaBase::convertFloat32ToIso(inc, conv);}
|
|
|
double convertFloat64ToIso(double inc, int conv) {return DsaBase::convertFloat64ToIso(inc, conv);}
|
|
|
long convertFromIso(double iso, int conv) {return DsaBase::convertFromIso(iso, conv);}
|
|
|
long convertInt32FromIso(double iso, int conv) {return DsaBase::convertInt32FromIso(iso, conv);}
|
|
|
eint64 convertInt64FromIso(double iso, int conv) {return DsaBase::convertInt64FromIso(iso, conv);}
|
|
|
float convertFloat32FromIso(double iso, int conv) {return DsaBase::convertFloat32FromIso(iso, conv);}
|
|
|
double convertFloat64FromIso(double iso, int conv) {return DsaBase::convertFloat64FromIso(iso, conv);}
|
|
|
double getIncToIsoFactor(int conv) {return DsaBase::getIncToIsoFactor(conv);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
DsaInfo getInfo() {return DsaBase::getInfo();}
|
|
|
DsaStatus getStatus() {return DsaBase::getStatus();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
DsaStatus getStatusFromDrive(long timeout = DEF_TIMEOUT) {return DsaBase::getStatusFromDrive(timeout);}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
double queryMinimumSampleTime() {return DsaBase::queryMinimumSampleTime();}
|
|
|
double querySampleTime(double time) {return DsaBase::querySampleTime(time);}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
DsaXInfo getXInfo() {return DsaBase::getXInfo();}
|
|
|
DmdData getDmdData() {return DsaBase::getDmdData();}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
void startUploadTrace(int traceTyp, int traceIdx, int startIdx, int endIdx, int stepIdx, bool fast, long timeout = DEF_TIMEOUT) {DsaBase::startUploadTrace(traceTyp, traceIdx, startIdx, endIdx, stepIdx, fast, timeout);}
|
|
|
void startUploadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startUploadSequence(timeout);}
|
|
|
void startUploadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startUploadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void uploadData(void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::uploadData(data, size, timeout);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDeviceGroup class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDeviceGroup: public DsaBase {
|
|
|
/* constructors */
|
|
|
private:
|
|
|
void _Group(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_device_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
protected:
|
|
|
DsaDeviceGroup(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaDeviceGroup(DsaDeviceGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDeviceGroup(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_device_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDeviceGroup(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_device_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
DsaDeviceGroup(int max, DsaDeviceBase *list[]) {
|
|
|
ERRCHK(dsa_create_device_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, list[i]->dsa));
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2) {
|
|
|
_Group(2, &d1, &d2);
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2, DsaDeviceBase d3) {
|
|
|
_Group(3, &d1, &d2, &d3);
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2, DsaDeviceBase d3, DsaDeviceBase d4) {
|
|
|
_Group(4, &d1, &d2, &d3, &d4);
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2, DsaDeviceBase d3, DsaDeviceBase d4, DsaDeviceBase d5) {
|
|
|
_Group(5, &d1, &d2, &d3, &d4, &d5);
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2, DsaDeviceBase d3, DsaDeviceBase d4, DsaDeviceBase d5, DsaDeviceBase d6) {
|
|
|
_Group(6, &d1, &d2, &d3, &d4, &d5, &d6);
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2, DsaDeviceBase d3, DsaDeviceBase d4, DsaDeviceBase d5, DsaDeviceBase d6, DsaDeviceBase d7) {
|
|
|
_Group(7, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
|
|
}
|
|
|
DsaDeviceGroup(DsaDeviceBase d1, DsaDeviceBase d2, DsaDeviceBase d3, DsaDeviceBase d4, DsaDeviceBase d5, DsaDeviceBase d6, DsaDeviceBase d7, DsaDeviceBase d8) {
|
|
|
_Group(8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8);
|
|
|
}
|
|
|
/* operators */
|
|
|
public:
|
|
|
DsaDeviceGroup operator = (DsaDeviceGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDeviceGroup operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_device_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* special functions */
|
|
|
public:
|
|
|
DsaDeviceBase getGroupItem(int pos) {return DsaBase::getGroupItem(pos);}
|
|
|
/* functions */
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
int getGroupSize() {return DsaBase::getGroupSize();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDriveBase class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDriveBase: public DsaBase {
|
|
|
/* constructors */
|
|
|
protected:
|
|
|
DsaDriveBase(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaDriveBase(DsaDriveBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDriveBase(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaDriveBase operator = (DsaDriveBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDriveBase operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void powerOn(long timeout = DEF_TIMEOUT) {DsaBase::powerOn(timeout);}
|
|
|
void powerOff(long timeout = DEF_TIMEOUT) {DsaBase::powerOff(timeout);}
|
|
|
void newSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::newSetpoint(sidx, flags, timeout);}
|
|
|
void changeSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::changeSetpoint(sidx, flags, timeout);}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void homingStart(long timeout = DEF_TIMEOUT) {DsaBase::homingStart(timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, long timeout = DEF_TIMEOUT) {DsaBase::startProfiledMovement(pos, speed, acc, timeout);}
|
|
|
void startRelativeProfiledMovement(double relativePos, long timeout = DEF_TIMEOUT) {DsaBase::startRelativeProfiledMovement(relativePos, timeout);}
|
|
|
void stageMappingDownload(const char *fileName) {DsaBase::stageMappingDownload(fileName);}
|
|
|
void stageMappingUpload(const char *fileName) {DsaBase::stageMappingUpload(fileName);}
|
|
|
void stageMappingActivate() {DsaBase::stageMappingActivate();}
|
|
|
void stageMappingDeactivate() {DsaBase::stageMappingDeactivate();}
|
|
|
bool stageMappingIsActivated() {return DsaBase::stageMappingIsActivated();}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void powerOn(DsaHandler handler, void *param = NULL) {DsaBase::powerOn(handler, param);}
|
|
|
void powerOff(DsaHandler handler, void *param = NULL) {DsaBase::powerOff(handler, param);}
|
|
|
void newSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::newSetpoint(sidx, flags, handler, param);}
|
|
|
void changeSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::changeSetpoint(sidx, flags, handler, param);}
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void homingStart(DsaHandler handler, void *param = NULL) {DsaBase::homingStart(handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, DsaHandler handler, void *param = NULL) {DsaBase::startProfiledMovement(pos, speed, acc, handler, param);}
|
|
|
void startRelativeProfiledMovement(double relativePos, DsaHandler handler, void *param = NULL) {DsaBase::startRelativeProfiledMovement(relativePos, handler, param);}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void getRtmMon(DsaRTM *rtm) {DsaBase::getRtmMon(rtm);}
|
|
|
void initRtmFct() {DsaBase::initRtmFct();}
|
|
|
void startRtm(DsaTrajectoryHandler fct) {DsaBase::startRtm(fct);}
|
|
|
void stopRtm() {DsaBase::stopRtm();}
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void stepMotion(double pos, long timeout = DEF_TIMEOUT) {DsaBase::stepMotion(pos, timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void canCommand1(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand1(val1, val2, timeout);}
|
|
|
void canCommand2(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand2(val1, val2, timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void stepMotion(double pos, DsaHandler handler, void *param = NULL) {DsaBase::stepMotion(pos, handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void canCommand1(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand1(val1, val2, handler, param);}
|
|
|
void canCommand2(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand2(val1, val2, handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
|
|
|
/* register setters */
|
|
|
void setPLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLProportionalGain(gain, timeout);}
|
|
|
void setPLSpeedFeedbackGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedbackGain(gain, timeout);}
|
|
|
void setPLForceFeedbackGain1(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain1(gain, timeout);}
|
|
|
void setPLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorGain(gain, timeout);}
|
|
|
void setPLAntiWindupGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLAntiWindupGain(gain, timeout);}
|
|
|
void setPLIntegratorLimitation(double limit, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorLimitation(limit, timeout);}
|
|
|
void setPLIntegratorMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorMode(mode, timeout);}
|
|
|
void setPLSpeedFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFilter(tim, timeout);}
|
|
|
void setPLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLOutputFilter(tim, timeout);}
|
|
|
void setCLInputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLInputFilter(tim, timeout);}
|
|
|
void setTtlSpecialFilter(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setTtlSpecialFilter(factor, timeout);}
|
|
|
void setPLForceFeedbackGain2(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain2(factor, timeout);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedfwdGain(factor, timeout);}
|
|
|
void setPLAccFeedforwardGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLAccFeedforwardGain(factor, timeout);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceFactor(factor, timeout);}
|
|
|
void setAprInputFilter(double time, long timeout = DEF_TIMEOUT) {DsaBase::setAprInputFilter(time, timeout);}
|
|
|
void setCLPhaseAdvanceShift(double shift, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceShift(shift, timeout);}
|
|
|
void setMinPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxProfileVelocity(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setMaxProfileVelocity(vel, timeout);}
|
|
|
void setMaxAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setMaxAcceleration(acc, timeout);}
|
|
|
void startMovement(double *targets, long timeout = DEF_TIMEOUT) {DsaBase::startMovement(targets, timeout);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setFollowingErrorWindow(pos, timeout);}
|
|
|
void setVelocityErrorLimit(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setVelocityErrorLimit(vel, timeout);}
|
|
|
void setSwitchLimitMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setSwitchLimitMode(mode, timeout);}
|
|
|
void setEnableInputMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setEnableInputMode(mode, timeout);}
|
|
|
void setMinSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinSoftPositionLimit(pos, timeout);}
|
|
|
void setMaxSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxSoftPositionLimit(pos, timeout);}
|
|
|
void setProfileLimitMode(dword flags, long timeout = DEF_TIMEOUT) {DsaBase::setProfileLimitMode(flags, timeout);}
|
|
|
void setIOErrorEventMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setIOErrorEventMask(mask, timeout);}
|
|
|
void setPositionWindowTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindowTime(tim, timeout);}
|
|
|
void setPositionWindow(double win, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindow(win, timeout);}
|
|
|
void setHomingMethod(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingMethod(mode, timeout);}
|
|
|
void setHomingZeroSpeed(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setHomingZeroSpeed(vel, timeout);}
|
|
|
void setHomingAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setHomingAcceleration(acc, timeout);}
|
|
|
void setHomingFollowingLimit(double win, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFollowingLimit(win, timeout);}
|
|
|
void setHomingCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setHomingCurrentLimit(cur, timeout);}
|
|
|
void setHomeOffset(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomeOffset(pos, timeout);}
|
|
|
void setHomingFixedMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFixedMvt(pos, timeout);}
|
|
|
void setHomingSwitchMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingSwitchMvt(pos, timeout);}
|
|
|
void setHomingIndexMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingIndexMvt(pos, timeout);}
|
|
|
void setHomingFineTuningMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningMode(mode, timeout);}
|
|
|
void setHomingFineTuningValue(double phase, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningValue(phase, timeout);}
|
|
|
void setMotorPhaseCorrection(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setMotorPhaseCorrection(mode, timeout);}
|
|
|
void setSoftwareCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setSoftwareCurrentLimit(cur, timeout);}
|
|
|
void setDriveControlMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDriveControlMode(mode, timeout);}
|
|
|
void setDisplayMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDisplayMode(mode, timeout);}
|
|
|
void setEncoderInversion(double invert, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderInversion(invert, timeout);}
|
|
|
void setPdrStepValue(double step, long timeout = DEF_TIMEOUT) {DsaBase::setPdrStepValue(step, timeout);}
|
|
|
void setEncoderPhase1Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Offset(offset, timeout);}
|
|
|
void setEncoderPhase2Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Offset(offset, timeout);}
|
|
|
void setEncoderPhase1Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Factor(factor, timeout);}
|
|
|
void setEncoderPhase2Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Factor(factor, timeout);}
|
|
|
void setEncoderPhase3Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Offset(offset, timeout);}
|
|
|
void setEncoderIndexDistance(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderIndexDistance(pos, timeout);}
|
|
|
void setEncoderPhase3Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Factor(factor, timeout);}
|
|
|
void setCLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLProportionalGain(gain, timeout);}
|
|
|
void setCLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLIntegratorGain(gain, timeout);}
|
|
|
void setCLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLOutputFilter(tim, timeout);}
|
|
|
void setCLCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tTimeLimit(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tTimeLimit(tim, timeout);}
|
|
|
void setCLRegenMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setCLRegenMode(mode, timeout);}
|
|
|
void setInitMode(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setInitMode(typ, timeout);}
|
|
|
void setInitPulseLevel(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitPulseLevel(cur, timeout);}
|
|
|
void setInitMaxCurrent(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitMaxCurrent(cur, timeout);}
|
|
|
void setInitFinalPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitFinalPhase(cal, timeout);}
|
|
|
void setInitTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setInitTime(tim, timeout);}
|
|
|
void setInitCurrentRate(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitCurrentRate(cur, timeout);}
|
|
|
void setInitPhaseRate(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitPhaseRate(cal, timeout);}
|
|
|
void setInitInitialPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitInitialPhase(cal, timeout);}
|
|
|
void setDriveFuseChecking(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setDriveFuseChecking(mask, timeout);}
|
|
|
void setMotorTempChecking(dword val, long timeout = DEF_TIMEOUT) {DsaBase::setMotorTempChecking(val, timeout);}
|
|
|
void setMonSourceType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceType(sidx, typ, timeout);}
|
|
|
void setMonSourceIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceIndex(sidx, index, timeout);}
|
|
|
void setMonDestIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonDestIndex(sidx, index, timeout);}
|
|
|
void setMonOffset(int sidx, long offset, long timeout = DEF_TIMEOUT) {DsaBase::setMonOffset(sidx, offset, timeout);}
|
|
|
void setMonGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setMonGain(sidx, gain, timeout);}
|
|
|
void setXAnalogOffset(int sidx, double offset, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOffset(sidx, offset, timeout);}
|
|
|
void setXAnalogGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogGain(sidx, gain, timeout);}
|
|
|
void setSyncroInputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputMask(mask, timeout);}
|
|
|
void setSyncroInputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputValue(mask, timeout);}
|
|
|
void setSyncroOutputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputMask(mask, timeout);}
|
|
|
void setSyncroOutputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputValue(mask, timeout);}
|
|
|
void setSyncroStartTimeout(int tim, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroStartTimeout(tim, timeout);}
|
|
|
void setDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setDigitalOutput(out, timeout);}
|
|
|
void setXDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setXDigitalOutput(out, timeout);}
|
|
|
void setXAnalogOutput1(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput1(out, timeout);}
|
|
|
void setXAnalogOutput2(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput2(out, timeout);}
|
|
|
void setXAnalogOutput3(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput3(out, timeout);}
|
|
|
void setXAnalogOutput4(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput4(out, timeout);}
|
|
|
void setAnalogOutput(double out, long timeout = DEF_TIMEOUT) {DsaBase::setAnalogOutput(out, timeout);}
|
|
|
void setInterruptMask1(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask1(sidx, mask, timeout);}
|
|
|
void setInterruptMask2(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask2(sidx, mask, timeout);}
|
|
|
void setTriggerIrqMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIrqMask(mask, timeout);}
|
|
|
void setTriggerIOMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIOMask(mask, timeout);}
|
|
|
void setTriggerMapOffset(int offset, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapOffset(offset, timeout);}
|
|
|
void setTriggerMapSize(int size, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapSize(size, timeout);}
|
|
|
void setRealtimeEnabledGlobal(int enable, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledGlobal(enable, timeout);}
|
|
|
void setRealtimeValidMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeValidMask(mask, timeout);}
|
|
|
void setRealtimeEnabledMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledMask(mask, timeout);}
|
|
|
void setRealtimePendingMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimePendingMask(mask, timeout);}
|
|
|
void setEblBaudrate(long baud, long timeout = DEF_TIMEOUT) {DsaBase::setEblBaudrate(baud, timeout);}
|
|
|
void setIndirectAxisNumber(int axis, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectAxisNumber(axis, timeout);}
|
|
|
void setIndirectRegisterIdx(int idx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterIdx(idx, timeout);}
|
|
|
void setIndirectRegisterSidx(int sidx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterSidx(sidx, timeout);}
|
|
|
void setConcatenatedMvt(int concat, long timeout = DEF_TIMEOUT) {DsaBase::setConcatenatedMvt(concat, timeout);}
|
|
|
void setProfileType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setProfileType(sidx, typ, timeout);}
|
|
|
void setMvtLktNumber(int sidx, int number, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktNumber(sidx, number, timeout);}
|
|
|
void setMvtLktTime(int sidx, double time, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktTime(sidx, time, timeout);}
|
|
|
void setCameValue(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCameValue(factor, timeout);}
|
|
|
void setBrakeDeceleration(double dec, long timeout = DEF_TIMEOUT) {DsaBase::setBrakeDeceleration(dec, timeout);}
|
|
|
void setTargetPosition(int sidx, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTargetPosition(sidx, pos, timeout);}
|
|
|
void setProfileVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setProfileVelocity(sidx, vel, timeout);}
|
|
|
void setProfileAcceleration(int sidx, double acc, long timeout = DEF_TIMEOUT) {DsaBase::setProfileAcceleration(sidx, acc, timeout);}
|
|
|
void setJerkTime(int sidx, double tim, long timeout = DEF_TIMEOUT) {DsaBase::setJerkTime(sidx, tim, timeout);}
|
|
|
void setProfileDeceleration(int sidx, double dec, long timeout = DEF_TIMEOUT) {DsaBase::setProfileDeceleration(sidx, dec, timeout);}
|
|
|
void setEndVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setEndVelocity(sidx, vel, timeout);}
|
|
|
void setCtrlSourceType(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceType(typ, timeout);}
|
|
|
void setCtrlSourceIndex(int index, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceIndex(index, timeout);}
|
|
|
void setCtrlShiftFactor(int shift, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlShiftFactor(shift, timeout);}
|
|
|
void setCtrlOffset(long offset, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlOffset(offset, timeout);}
|
|
|
void setCtrlGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlGain(gain, timeout);}
|
|
|
void setMotorKTFactor(double kt, long timeout = DEF_TIMEOUT) {DsaBase::setMotorKTFactor(kt, timeout);}
|
|
|
|
|
|
void setPLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLProportionalGain(gain, handler, param);}
|
|
|
void setPLSpeedFeedbackGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedbackGain(gain, handler, param);}
|
|
|
void setPLForceFeedbackGain1(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain1(gain, handler, param);}
|
|
|
void setPLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorGain(gain, handler, param);}
|
|
|
void setPLAntiWindupGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLAntiWindupGain(gain, handler, param);}
|
|
|
void setPLIntegratorLimitation(double limit, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorLimitation(limit, handler, param);}
|
|
|
void setPLIntegratorMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorMode(mode, handler, param);}
|
|
|
void setPLSpeedFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFilter(tim, handler, param);}
|
|
|
void setPLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLOutputFilter(tim, handler, param);}
|
|
|
void setCLInputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLInputFilter(tim, handler, param);}
|
|
|
void setTtlSpecialFilter(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setTtlSpecialFilter(factor, handler, param);}
|
|
|
void setPLForceFeedbackGain2(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain2(factor, handler, param);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedfwdGain(factor, handler, param);}
|
|
|
void setPLAccFeedforwardGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLAccFeedforwardGain(factor, handler, param);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceFactor(factor, handler, param);}
|
|
|
void setAprInputFilter(double time, DsaHandler handler, void *param = NULL) {DsaBase::setAprInputFilter(time, handler, param);}
|
|
|
void setCLPhaseAdvanceShift(double shift, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceShift(shift, handler, param);}
|
|
|
void setMinPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxProfileVelocity(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setMaxProfileVelocity(vel, handler, param);}
|
|
|
void setMaxAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setMaxAcceleration(acc, handler, param);}
|
|
|
void startMovement(double *targets, DsaHandler handler, void *param = NULL) {DsaBase::startMovement(targets, handler, param);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setFollowingErrorWindow(pos, handler, param);}
|
|
|
void setVelocityErrorLimit(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setVelocityErrorLimit(vel, handler, param);}
|
|
|
void setSwitchLimitMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setSwitchLimitMode(mode, handler, param);}
|
|
|
void setEnableInputMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setEnableInputMode(mode, handler, param);}
|
|
|
void setMinSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinSoftPositionLimit(pos, handler, param);}
|
|
|
void setMaxSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxSoftPositionLimit(pos, handler, param);}
|
|
|
void setProfileLimitMode(dword flags, DsaHandler handler, void *param = NULL) {DsaBase::setProfileLimitMode(flags, handler, param);}
|
|
|
void setIOErrorEventMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setIOErrorEventMask(mask, handler, param);}
|
|
|
void setPositionWindowTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindowTime(tim, handler, param);}
|
|
|
void setPositionWindow(double win, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindow(win, handler, param);}
|
|
|
void setHomingMethod(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingMethod(mode, handler, param);}
|
|
|
void setHomingZeroSpeed(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setHomingZeroSpeed(vel, handler, param);}
|
|
|
void setHomingAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setHomingAcceleration(acc, handler, param);}
|
|
|
void setHomingFollowingLimit(double win, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFollowingLimit(win, handler, param);}
|
|
|
void setHomingCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setHomingCurrentLimit(cur, handler, param);}
|
|
|
void setHomeOffset(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomeOffset(pos, handler, param);}
|
|
|
void setHomingFixedMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFixedMvt(pos, handler, param);}
|
|
|
void setHomingSwitchMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingSwitchMvt(pos, handler, param);}
|
|
|
void setHomingIndexMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingIndexMvt(pos, handler, param);}
|
|
|
void setHomingFineTuningMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningMode(mode, handler, param);}
|
|
|
void setHomingFineTuningValue(double phase, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningValue(phase, handler, param);}
|
|
|
void setMotorPhaseCorrection(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setMotorPhaseCorrection(mode, handler, param);}
|
|
|
void setSoftwareCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setSoftwareCurrentLimit(cur, handler, param);}
|
|
|
void setDriveControlMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDriveControlMode(mode, handler, param);}
|
|
|
void setDisplayMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDisplayMode(mode, handler, param);}
|
|
|
void setEncoderInversion(double invert, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderInversion(invert, handler, param);}
|
|
|
void setPdrStepValue(double step, DsaHandler handler, void *param = NULL) {DsaBase::setPdrStepValue(step, handler, param);}
|
|
|
void setEncoderPhase1Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Offset(offset, handler, param);}
|
|
|
void setEncoderPhase2Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Offset(offset, handler, param);}
|
|
|
void setEncoderPhase1Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Factor(factor, handler, param);}
|
|
|
void setEncoderPhase2Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Factor(factor, handler, param);}
|
|
|
void setEncoderPhase3Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Offset(offset, handler, param);}
|
|
|
void setEncoderIndexDistance(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderIndexDistance(pos, handler, param);}
|
|
|
void setEncoderPhase3Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Factor(factor, handler, param);}
|
|
|
void setCLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLProportionalGain(gain, handler, param);}
|
|
|
void setCLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLIntegratorGain(gain, handler, param);}
|
|
|
void setCLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLOutputFilter(tim, handler, param);}
|
|
|
void setCLCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tTimeLimit(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tTimeLimit(tim, handler, param);}
|
|
|
void setCLRegenMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setCLRegenMode(mode, handler, param);}
|
|
|
void setInitMode(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setInitMode(typ, handler, param);}
|
|
|
void setInitPulseLevel(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitPulseLevel(cur, handler, param);}
|
|
|
void setInitMaxCurrent(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitMaxCurrent(cur, handler, param);}
|
|
|
void setInitFinalPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitFinalPhase(cal, handler, param);}
|
|
|
void setInitTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setInitTime(tim, handler, param);}
|
|
|
void setInitCurrentRate(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitCurrentRate(cur, handler, param);}
|
|
|
void setInitPhaseRate(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitPhaseRate(cal, handler, param);}
|
|
|
void setInitInitialPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitInitialPhase(cal, handler, param);}
|
|
|
void setDriveFuseChecking(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setDriveFuseChecking(mask, handler, param);}
|
|
|
void setMotorTempChecking(dword val, DsaHandler handler, void *param = NULL) {DsaBase::setMotorTempChecking(val, handler, param);}
|
|
|
void setMonSourceType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceType(sidx, typ, handler, param);}
|
|
|
void setMonSourceIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceIndex(sidx, index, handler, param);}
|
|
|
void setMonDestIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonDestIndex(sidx, index, handler, param);}
|
|
|
void setMonOffset(int sidx, long offset, DsaHandler handler, void *param = NULL) {DsaBase::setMonOffset(sidx, offset, handler, param);}
|
|
|
void setMonGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setMonGain(sidx, gain, handler, param);}
|
|
|
void setXAnalogOffset(int sidx, double offset, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOffset(sidx, offset, handler, param);}
|
|
|
void setXAnalogGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogGain(sidx, gain, handler, param);}
|
|
|
void setSyncroInputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputMask(mask, handler, param);}
|
|
|
void setSyncroInputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputValue(mask, handler, param);}
|
|
|
void setSyncroOutputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputMask(mask, handler, param);}
|
|
|
void setSyncroOutputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputValue(mask, handler, param);}
|
|
|
void setSyncroStartTimeout(int tim, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroStartTimeout(tim, handler, param);}
|
|
|
void setDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setDigitalOutput(out, handler, param);}
|
|
|
void setXDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setXDigitalOutput(out, handler, param);}
|
|
|
void setXAnalogOutput1(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput1(out, handler, param);}
|
|
|
void setXAnalogOutput2(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput2(out, handler, param);}
|
|
|
void setXAnalogOutput3(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput3(out, handler, param);}
|
|
|
void setXAnalogOutput4(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput4(out, handler, param);}
|
|
|
void setAnalogOutput(double out, DsaHandler handler, void *param = NULL) {DsaBase::setAnalogOutput(out, handler, param);}
|
|
|
void setInterruptMask1(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask1(sidx, mask, handler, param);}
|
|
|
void setInterruptMask2(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask2(sidx, mask, handler, param);}
|
|
|
void setTriggerIrqMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIrqMask(mask, handler, param);}
|
|
|
void setTriggerIOMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIOMask(mask, handler, param);}
|
|
|
void setTriggerMapOffset(int offset, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapOffset(offset, handler, param);}
|
|
|
void setTriggerMapSize(int size, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapSize(size, handler, param);}
|
|
|
void setRealtimeEnabledGlobal(int enable, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledGlobal(enable, handler, param);}
|
|
|
void setRealtimeValidMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeValidMask(mask, handler, param);}
|
|
|
void setRealtimeEnabledMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledMask(mask, handler, param);}
|
|
|
void setRealtimePendingMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimePendingMask(mask, handler, param);}
|
|
|
void setEblBaudrate(long baud, DsaHandler handler, void *param = NULL) {DsaBase::setEblBaudrate(baud, handler, param);}
|
|
|
void setIndirectAxisNumber(int axis, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectAxisNumber(axis, handler, param);}
|
|
|
void setIndirectRegisterIdx(int idx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterIdx(idx, handler, param);}
|
|
|
void setIndirectRegisterSidx(int sidx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterSidx(sidx, handler, param);}
|
|
|
void setConcatenatedMvt(int concat, DsaHandler handler, void *param = NULL) {DsaBase::setConcatenatedMvt(concat, handler, param);}
|
|
|
void setProfileType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setProfileType(sidx, typ, handler, param);}
|
|
|
void setMvtLktNumber(int sidx, int number, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktNumber(sidx, number, handler, param);}
|
|
|
void setMvtLktTime(int sidx, double time, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktTime(sidx, time, handler, param);}
|
|
|
void setCameValue(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCameValue(factor, handler, param);}
|
|
|
void setBrakeDeceleration(double dec, DsaHandler handler, void *param = NULL) {DsaBase::setBrakeDeceleration(dec, handler, param);}
|
|
|
void setTargetPosition(int sidx, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTargetPosition(sidx, pos, handler, param);}
|
|
|
void setProfileVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setProfileVelocity(sidx, vel, handler, param);}
|
|
|
void setProfileAcceleration(int sidx, double acc, DsaHandler handler, void *param = NULL) {DsaBase::setProfileAcceleration(sidx, acc, handler, param);}
|
|
|
void setJerkTime(int sidx, double tim, DsaHandler handler, void *param = NULL) {DsaBase::setJerkTime(sidx, tim, handler, param);}
|
|
|
void setProfileDeceleration(int sidx, double dec, DsaHandler handler, void *param = NULL) {DsaBase::setProfileDeceleration(sidx, dec, handler, param);}
|
|
|
void setEndVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setEndVelocity(sidx, vel, handler, param);}
|
|
|
void setCtrlSourceType(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceType(typ, handler, param);}
|
|
|
void setCtrlSourceIndex(int index, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceIndex(index, handler, param);}
|
|
|
void setCtrlShiftFactor(int shift, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlShiftFactor(shift, handler, param);}
|
|
|
void setCtrlOffset(long offset, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlOffset(offset, handler, param);}
|
|
|
void setCtrlGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlGain(gain, handler, param);}
|
|
|
void setMotorKTFactor(double kt, DsaHandler handler, void *param = NULL) {DsaBase::setMotorKTFactor(kt, handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDrive class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDrive: public DsaBase {
|
|
|
/* constructors */
|
|
|
public:
|
|
|
DsaDrive(void) {
|
|
|
dsa = NULL;
|
|
|
ERRCHK(dsa_create_drive(&dsa));
|
|
|
}
|
|
|
DsaDrive(DsaDrive &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDrive(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaDrive operator = (DsaDrive &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDrive operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void powerOn(long timeout = DEF_TIMEOUT) {DsaBase::powerOn(timeout);}
|
|
|
void powerOff(long timeout = DEF_TIMEOUT) {DsaBase::powerOff(timeout);}
|
|
|
void newSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::newSetpoint(sidx, flags, timeout);}
|
|
|
void changeSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::changeSetpoint(sidx, flags, timeout);}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void homingStart(long timeout = DEF_TIMEOUT) {DsaBase::homingStart(timeout);}
|
|
|
int getWarningCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getWarningCode(kind, timeout);}
|
|
|
int getErrorCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getErrorCode(kind, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, long timeout = DEF_TIMEOUT) {DsaBase::startProfiledMovement(pos, speed, acc, timeout);}
|
|
|
void startRelativeProfiledMovement(double relativePos, long timeout = DEF_TIMEOUT) {DsaBase::startRelativeProfiledMovement(relativePos, timeout);}
|
|
|
void stageMappingDownload(const char *fileName) {DsaBase::stageMappingDownload(fileName);}
|
|
|
void stageMappingUpload(const char *fileName) {DsaBase::stageMappingUpload(fileName);}
|
|
|
void stageMappingActivate() {DsaBase::stageMappingActivate();}
|
|
|
void stageMappingDeactivate() {DsaBase::stageMappingDeactivate();}
|
|
|
bool stageMappingIsActivated() {return DsaBase::stageMappingIsActivated();}
|
|
|
void scaleMappingDownload(const char *fileName, dword preProcessingMode) {return DsaBase::scaleMappingDownload(fileName, preProcessingMode);}
|
|
|
void scaleMappingActivate(dword mode) {return DsaBase::scaleMappingActivate(mode);}
|
|
|
void scaleMappingDeactivate() {return DsaBase::scaleMappingDeactivate();}
|
|
|
bool scaleMappingIsActivated() {return DsaBase::scaleMappingIsActivated();}
|
|
|
|
|
|
long getRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegister(typ, idx, sidx, kind, timeout);}
|
|
|
long getRegisterInt32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt32(typ, idx, sidx, kind, timeout);}
|
|
|
eint64 getRegisterInt64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt64(typ, idx, sidx, kind, timeout);}
|
|
|
float getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat32(typ, idx, sidx, kind, timeout);}
|
|
|
double getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat64(typ, idx, sidx, kind, timeout);}
|
|
|
float getFloatRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getFloatRegister(typ, idx, sidx, kind, timeout);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
double getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, timeout);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout = DEF_TIMEOUT) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, timeout);}
|
|
|
DsaStatus waitStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusChange(DsaStatus *mask, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusChange(mask, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void powerOn(DsaHandler handler, void *param = NULL) {DsaBase::powerOn(handler, param);}
|
|
|
void powerOff(DsaHandler handler, void *param = NULL) {DsaBase::powerOff(handler, param);}
|
|
|
void newSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::newSetpoint(sidx, flags, handler, param);}
|
|
|
void changeSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::changeSetpoint(sidx, flags, handler, param);}
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void homingStart(DsaHandler handler, void *param = NULL) {DsaBase::homingStart(handler, param);}
|
|
|
void getWarningCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getWarningCode(kind, handler, param);}
|
|
|
void getErrorCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getErrorCode(kind, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, DsaHandler handler, void *param = NULL) {DsaBase::startProfiledMovement(pos, speed, acc, handler, param);}
|
|
|
void startRelativeProfiledMovement(double relativePos, DsaHandler handler, void *param = NULL) {DsaBase::startRelativeProfiledMovement(relativePos, handler, param);}
|
|
|
|
|
|
void getRegister(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt32(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegisterInt32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt64(int typ, unsigned idx, int sidx, int kind, DsaInt64Handler handler, void *param = NULL) {DsaBase::getRegisterInt64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, DsaFloatHandler handler, void *param = NULL) {DsaBase::getRegisterFloat32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRegisterFloat64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getFloatRegister(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFloatRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, handler, param);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, Dsa2intHandler handler, void *param = NULL) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, handler, param);}
|
|
|
void waitStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusEqual(mask, ref, handler, param);}
|
|
|
void waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void waitStatusChange(DsaStatus *mask, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusChange(mask, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void open(EtbBus etb, int axis) {DsaBase::open(etb, axis);}
|
|
|
void etcomOpen(EtbBus etb, int axis) {DsaBase::etcomOpen(etb, axis);}
|
|
|
void open(char_cp url) {DsaBase::open(url);}
|
|
|
void open(EtbBus etb, int axis, dword flags) {DsaBase::open(etb, axis, flags);}
|
|
|
void etcomOpen(EtbBus etb, int axis, dword flags) {DsaBase::etcomOpen(etb, axis, flags);}
|
|
|
void reset() {DsaBase::reset();}
|
|
|
void close() {DsaBase::close();}
|
|
|
EtbBus getEtbBus() {return DsaBase::getEtbBus();}
|
|
|
int getEtbAxis() {return DsaBase::getEtbAxis();}
|
|
|
int etcomGetEtbAxis() {return DsaBase::etcomGetEtbAxis();}
|
|
|
bool isOpen() {return DsaBase::isOpen();}
|
|
|
int getMotorTyp() {return DsaBase::getMotorTyp();}
|
|
|
void getErrorText(char_p text, int size, int code) {DsaBase::getErrorText(text, size, code);}
|
|
|
void getWarningText(char_p text, int size, int code) {DsaBase::getWarningText(text, size, code);}
|
|
|
double convertToIso(long inc, int conv) {return DsaBase::convertToIso(inc, conv);}
|
|
|
double convertInt32ToIso(long inc, int conv) {return DsaBase::convertInt32ToIso(inc, conv);}
|
|
|
double convertInt64ToIso(eint64 inc, int conv) {return DsaBase::convertInt64ToIso(inc, conv);}
|
|
|
double convertFloat32ToIso(float inc, int conv) {return DsaBase::convertFloat32ToIso(inc, conv);}
|
|
|
double convertFloat64ToIso(double inc, int conv) {return DsaBase::convertFloat64ToIso(inc, conv);}
|
|
|
long convertFromIso(double iso, int conv) {return DsaBase::convertFromIso(iso, conv);}
|
|
|
long convertInt32FromIso(double iso, int conv) {return DsaBase::convertInt32FromIso(iso, conv);}
|
|
|
eint64 convertInt64FromIso(double iso, int conv) {return DsaBase::convertInt64FromIso(iso, conv);}
|
|
|
float convertFloat32FromIso(double iso, int conv) {return DsaBase::convertFloat32FromIso(iso, conv);}
|
|
|
double convertFloat64FromIso(double iso, int conv) {return DsaBase::convertFloat64FromIso(iso, conv);}
|
|
|
double getIncToIsoFactor(int conv) {return DsaBase::getIncToIsoFactor(conv);}
|
|
|
|
|
|
void getRtmMon(DsaRTM *rtm) {DsaBase::getRtmMon(rtm);}
|
|
|
void initRtmFct() {DsaBase::initRtmFct();}
|
|
|
void startRtm(DsaTrajectoryHandler fct) {DsaBase::startRtm(fct);}
|
|
|
void stopRtm() {DsaBase::stopRtm();}
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
DsaInfo getInfo() {return DsaBase::getInfo();}
|
|
|
DsaStatus getStatus() {return DsaBase::getStatus();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
DsaStatus getStatusFromDrive(long timeout = DEF_TIMEOUT) {return DsaBase::getStatusFromDrive(timeout);}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
double queryMinimumSampleTime() {return DsaBase::queryMinimumSampleTime();}
|
|
|
double querySampleTime(double time) {return DsaBase::querySampleTime(time);}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
DsaXInfo getXInfo() {return DsaBase::getXInfo();}
|
|
|
DmdData getDmdData() {return DsaBase::getDmdData();}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void stepMotion(double pos, long timeout = DEF_TIMEOUT) {DsaBase::stepMotion(pos, timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void canCommand1(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand1(val1, val2, timeout);}
|
|
|
void canCommand2(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand2(val1, val2, timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void stepMotion(double pos, DsaHandler handler, void *param = NULL) {DsaBase::stepMotion(pos, handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void canCommand1(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand1(val1, val2, handler, param);}
|
|
|
void canCommand2(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand2(val1, val2, handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
void startUploadTrace(int traceTyp, int traceIdx, int startIdx, int endIdx, int stepIdx, bool fast, long timeout = DEF_TIMEOUT) {DsaBase::startUploadTrace(traceTyp, traceIdx, startIdx, endIdx, stepIdx, fast, timeout);}
|
|
|
void startUploadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startUploadSequence(timeout);}
|
|
|
void startUploadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startUploadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void uploadData(void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::uploadData(data, size, timeout);}
|
|
|
|
|
|
/* register setters */
|
|
|
void setPLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLProportionalGain(gain, timeout);}
|
|
|
void setPLSpeedFeedbackGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedbackGain(gain, timeout);}
|
|
|
void setPLForceFeedbackGain1(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain1(gain, timeout);}
|
|
|
void setPLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorGain(gain, timeout);}
|
|
|
void setPLAntiWindupGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLAntiWindupGain(gain, timeout);}
|
|
|
void setPLIntegratorLimitation(double limit, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorLimitation(limit, timeout);}
|
|
|
void setPLIntegratorMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorMode(mode, timeout);}
|
|
|
void setPLSpeedFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFilter(tim, timeout);}
|
|
|
void setPLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLOutputFilter(tim, timeout);}
|
|
|
void setCLInputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLInputFilter(tim, timeout);}
|
|
|
void setTtlSpecialFilter(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setTtlSpecialFilter(factor, timeout);}
|
|
|
void setPLForceFeedbackGain2(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain2(factor, timeout);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedfwdGain(factor, timeout);}
|
|
|
void setPLAccFeedforwardGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLAccFeedforwardGain(factor, timeout);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceFactor(factor, timeout);}
|
|
|
void setAprInputFilter(double time, long timeout = DEF_TIMEOUT) {DsaBase::setAprInputFilter(time, timeout);}
|
|
|
void setCLPhaseAdvanceShift(double shift, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceShift(shift, timeout);}
|
|
|
void setMinPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxProfileVelocity(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setMaxProfileVelocity(vel, timeout);}
|
|
|
void setMaxAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setMaxAcceleration(acc, timeout);}
|
|
|
void startMovement(double *targets, long timeout = DEF_TIMEOUT) {DsaBase::startMovement(targets, timeout);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setFollowingErrorWindow(pos, timeout);}
|
|
|
void setVelocityErrorLimit(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setVelocityErrorLimit(vel, timeout);}
|
|
|
void setSwitchLimitMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setSwitchLimitMode(mode, timeout);}
|
|
|
void setEnableInputMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setEnableInputMode(mode, timeout);}
|
|
|
void setMinSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinSoftPositionLimit(pos, timeout);}
|
|
|
void setMaxSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxSoftPositionLimit(pos, timeout);}
|
|
|
void setProfileLimitMode(dword flags, long timeout = DEF_TIMEOUT) {DsaBase::setProfileLimitMode(flags, timeout);}
|
|
|
void setIOErrorEventMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setIOErrorEventMask(mask, timeout);}
|
|
|
void setPositionWindowTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindowTime(tim, timeout);}
|
|
|
void setPositionWindow(double win, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindow(win, timeout);}
|
|
|
void setHomingMethod(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingMethod(mode, timeout);}
|
|
|
void setHomingZeroSpeed(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setHomingZeroSpeed(vel, timeout);}
|
|
|
void setHomingAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setHomingAcceleration(acc, timeout);}
|
|
|
void setHomingFollowingLimit(double win, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFollowingLimit(win, timeout);}
|
|
|
void setHomingCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setHomingCurrentLimit(cur, timeout);}
|
|
|
void setHomeOffset(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomeOffset(pos, timeout);}
|
|
|
void setHomingFixedMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFixedMvt(pos, timeout);}
|
|
|
void setHomingSwitchMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingSwitchMvt(pos, timeout);}
|
|
|
void setHomingIndexMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingIndexMvt(pos, timeout);}
|
|
|
void setHomingFineTuningMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningMode(mode, timeout);}
|
|
|
void setHomingFineTuningValue(double phase, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningValue(phase, timeout);}
|
|
|
void setMotorPhaseCorrection(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setMotorPhaseCorrection(mode, timeout);}
|
|
|
void setSoftwareCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setSoftwareCurrentLimit(cur, timeout);}
|
|
|
void setDriveControlMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDriveControlMode(mode, timeout);}
|
|
|
void setDisplayMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDisplayMode(mode, timeout);}
|
|
|
void setEncoderInversion(double invert, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderInversion(invert, timeout);}
|
|
|
void setPdrStepValue(double step, long timeout = DEF_TIMEOUT) {DsaBase::setPdrStepValue(step, timeout);}
|
|
|
void setEncoderPhase1Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Offset(offset, timeout);}
|
|
|
void setEncoderPhase2Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Offset(offset, timeout);}
|
|
|
void setEncoderPhase1Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Factor(factor, timeout);}
|
|
|
void setEncoderPhase2Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Factor(factor, timeout);}
|
|
|
void setEncoderPhase3Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Offset(offset, timeout);}
|
|
|
void setEncoderIndexDistance(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderIndexDistance(pos, timeout);}
|
|
|
void setEncoderPhase3Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Factor(factor, timeout);}
|
|
|
void setCLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLProportionalGain(gain, timeout);}
|
|
|
void setCLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLIntegratorGain(gain, timeout);}
|
|
|
void setCLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLOutputFilter(tim, timeout);}
|
|
|
void setCLCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tTimeLimit(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tTimeLimit(tim, timeout);}
|
|
|
void setCLRegenMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setCLRegenMode(mode, timeout);}
|
|
|
void setInitMode(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setInitMode(typ, timeout);}
|
|
|
void setInitPulseLevel(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitPulseLevel(cur, timeout);}
|
|
|
void setInitMaxCurrent(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitMaxCurrent(cur, timeout);}
|
|
|
void setInitFinalPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitFinalPhase(cal, timeout);}
|
|
|
void setInitTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setInitTime(tim, timeout);}
|
|
|
void setInitCurrentRate(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitCurrentRate(cur, timeout);}
|
|
|
void setInitPhaseRate(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitPhaseRate(cal, timeout);}
|
|
|
void setInitInitialPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitInitialPhase(cal, timeout);}
|
|
|
void setDriveFuseChecking(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setDriveFuseChecking(mask, timeout);}
|
|
|
void setMotorTempChecking(dword val, long timeout = DEF_TIMEOUT) {DsaBase::setMotorTempChecking(val, timeout);}
|
|
|
void setMonSourceType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceType(sidx, typ, timeout);}
|
|
|
void setMonSourceIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceIndex(sidx, index, timeout);}
|
|
|
void setMonDestIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonDestIndex(sidx, index, timeout);}
|
|
|
void setMonOffset(int sidx, long offset, long timeout = DEF_TIMEOUT) {DsaBase::setMonOffset(sidx, offset, timeout);}
|
|
|
void setMonGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setMonGain(sidx, gain, timeout);}
|
|
|
void setXAnalogOffset(int sidx, double offset, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOffset(sidx, offset, timeout);}
|
|
|
void setXAnalogGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogGain(sidx, gain, timeout);}
|
|
|
void setSyncroInputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputMask(mask, timeout);}
|
|
|
void setSyncroInputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputValue(mask, timeout);}
|
|
|
void setSyncroOutputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputMask(mask, timeout);}
|
|
|
void setSyncroOutputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputValue(mask, timeout);}
|
|
|
void setSyncroStartTimeout(int tim, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroStartTimeout(tim, timeout);}
|
|
|
void setDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setDigitalOutput(out, timeout);}
|
|
|
void setXDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setXDigitalOutput(out, timeout);}
|
|
|
void setXAnalogOutput1(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput1(out, timeout);}
|
|
|
void setXAnalogOutput2(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput2(out, timeout);}
|
|
|
void setXAnalogOutput3(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput3(out, timeout);}
|
|
|
void setXAnalogOutput4(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput4(out, timeout);}
|
|
|
void setAnalogOutput(double out, long timeout = DEF_TIMEOUT) {DsaBase::setAnalogOutput(out, timeout);}
|
|
|
void setInterruptMask1(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask1(sidx, mask, timeout);}
|
|
|
void setInterruptMask2(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask2(sidx, mask, timeout);}
|
|
|
void setTriggerIrqMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIrqMask(mask, timeout);}
|
|
|
void setTriggerIOMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIOMask(mask, timeout);}
|
|
|
void setTriggerMapOffset(int offset, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapOffset(offset, timeout);}
|
|
|
void setTriggerMapSize(int size, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapSize(size, timeout);}
|
|
|
void setRealtimeEnabledGlobal(int enable, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledGlobal(enable, timeout);}
|
|
|
void setRealtimeValidMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeValidMask(mask, timeout);}
|
|
|
void setRealtimeEnabledMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledMask(mask, timeout);}
|
|
|
void setRealtimePendingMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimePendingMask(mask, timeout);}
|
|
|
void setEblBaudrate(long baud, long timeout = DEF_TIMEOUT) {DsaBase::setEblBaudrate(baud, timeout);}
|
|
|
void setIndirectAxisNumber(int axis, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectAxisNumber(axis, timeout);}
|
|
|
void setIndirectRegisterIdx(int idx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterIdx(idx, timeout);}
|
|
|
void setIndirectRegisterSidx(int sidx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterSidx(sidx, timeout);}
|
|
|
void setConcatenatedMvt(int concat, long timeout = DEF_TIMEOUT) {DsaBase::setConcatenatedMvt(concat, timeout);}
|
|
|
void setProfileType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setProfileType(sidx, typ, timeout);}
|
|
|
void setMvtLktNumber(int sidx, int number, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktNumber(sidx, number, timeout);}
|
|
|
void setMvtLktTime(int sidx, double time, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktTime(sidx, time, timeout);}
|
|
|
void setCameValue(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCameValue(factor, timeout);}
|
|
|
void setBrakeDeceleration(double dec, long timeout = DEF_TIMEOUT) {DsaBase::setBrakeDeceleration(dec, timeout);}
|
|
|
void setTargetPosition(int sidx, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTargetPosition(sidx, pos, timeout);}
|
|
|
void setProfileVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setProfileVelocity(sidx, vel, timeout);}
|
|
|
void setProfileAcceleration(int sidx, double acc, long timeout = DEF_TIMEOUT) {DsaBase::setProfileAcceleration(sidx, acc, timeout);}
|
|
|
void setJerkTime(int sidx, double tim, long timeout = DEF_TIMEOUT) {DsaBase::setJerkTime(sidx, tim, timeout);}
|
|
|
void setProfileDeceleration(int sidx, double dec, long timeout = DEF_TIMEOUT) {DsaBase::setProfileDeceleration(sidx, dec, timeout);}
|
|
|
void setEndVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setEndVelocity(sidx, vel, timeout);}
|
|
|
void setCtrlSourceType(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceType(typ, timeout);}
|
|
|
void setCtrlSourceIndex(int index, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceIndex(index, timeout);}
|
|
|
void setCtrlShiftFactor(int shift, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlShiftFactor(shift, timeout);}
|
|
|
void setCtrlOffset(long offset, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlOffset(offset, timeout);}
|
|
|
void setCtrlGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlGain(gain, timeout);}
|
|
|
void setMotorKTFactor(double kt, long timeout = DEF_TIMEOUT) {DsaBase::setMotorKTFactor(kt, timeout);}
|
|
|
|
|
|
void setPLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLProportionalGain(gain, handler, param);}
|
|
|
void setPLSpeedFeedbackGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedbackGain(gain, handler, param);}
|
|
|
void setPLForceFeedbackGain1(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain1(gain, handler, param);}
|
|
|
void setPLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorGain(gain, handler, param);}
|
|
|
void setPLAntiWindupGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLAntiWindupGain(gain, handler, param);}
|
|
|
void setPLIntegratorLimitation(double limit, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorLimitation(limit, handler, param);}
|
|
|
void setPLIntegratorMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorMode(mode, handler, param);}
|
|
|
void setPLSpeedFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFilter(tim, handler, param);}
|
|
|
void setPLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLOutputFilter(tim, handler, param);}
|
|
|
void setCLInputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLInputFilter(tim, handler, param);}
|
|
|
void setTtlSpecialFilter(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setTtlSpecialFilter(factor, handler, param);}
|
|
|
void setPLForceFeedbackGain2(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain2(factor, handler, param);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedfwdGain(factor, handler, param);}
|
|
|
void setPLAccFeedforwardGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLAccFeedforwardGain(factor, handler, param);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceFactor(factor, handler, param);}
|
|
|
void setAprInputFilter(double time, DsaHandler handler, void *param = NULL) {DsaBase::setAprInputFilter(time, handler, param);}
|
|
|
void setCLPhaseAdvanceShift(double shift, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceShift(shift, handler, param);}
|
|
|
void setMinPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxProfileVelocity(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setMaxProfileVelocity(vel, handler, param);}
|
|
|
void setMaxAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setMaxAcceleration(acc, handler, param);}
|
|
|
void startMovement(double *targets, DsaHandler handler, void *param = NULL) {DsaBase::startMovement(targets, handler, param);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setFollowingErrorWindow(pos, handler, param);}
|
|
|
void setVelocityErrorLimit(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setVelocityErrorLimit(vel, handler, param);}
|
|
|
void setSwitchLimitMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setSwitchLimitMode(mode, handler, param);}
|
|
|
void setEnableInputMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setEnableInputMode(mode, handler, param);}
|
|
|
void setMinSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinSoftPositionLimit(pos, handler, param);}
|
|
|
void setMaxSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxSoftPositionLimit(pos, handler, param);}
|
|
|
void setProfileLimitMode(dword flags, DsaHandler handler, void *param = NULL) {DsaBase::setProfileLimitMode(flags, handler, param);}
|
|
|
void setIOErrorEventMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setIOErrorEventMask(mask, handler, param);}
|
|
|
void setPositionWindowTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindowTime(tim, handler, param);}
|
|
|
void setPositionWindow(double win, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindow(win, handler, param);}
|
|
|
void setHomingMethod(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingMethod(mode, handler, param);}
|
|
|
void setHomingZeroSpeed(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setHomingZeroSpeed(vel, handler, param);}
|
|
|
void setHomingAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setHomingAcceleration(acc, handler, param);}
|
|
|
void setHomingFollowingLimit(double win, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFollowingLimit(win, handler, param);}
|
|
|
void setHomingCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setHomingCurrentLimit(cur, handler, param);}
|
|
|
void setHomeOffset(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomeOffset(pos, handler, param);}
|
|
|
void setHomingFixedMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFixedMvt(pos, handler, param);}
|
|
|
void setHomingSwitchMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingSwitchMvt(pos, handler, param);}
|
|
|
void setHomingIndexMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingIndexMvt(pos, handler, param);}
|
|
|
void setHomingFineTuningMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningMode(mode, handler, param);}
|
|
|
void setHomingFineTuningValue(double phase, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningValue(phase, handler, param);}
|
|
|
void setMotorPhaseCorrection(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setMotorPhaseCorrection(mode, handler, param);}
|
|
|
void setSoftwareCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setSoftwareCurrentLimit(cur, handler, param);}
|
|
|
void setDriveControlMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDriveControlMode(mode, handler, param);}
|
|
|
void setDisplayMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDisplayMode(mode, handler, param);}
|
|
|
void setEncoderInversion(double invert, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderInversion(invert, handler, param);}
|
|
|
void setPdrStepValue(double step, DsaHandler handler, void *param = NULL) {DsaBase::setPdrStepValue(step, handler, param);}
|
|
|
void setEncoderPhase1Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Offset(offset, handler, param);}
|
|
|
void setEncoderPhase2Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Offset(offset, handler, param);}
|
|
|
void setEncoderPhase1Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Factor(factor, handler, param);}
|
|
|
void setEncoderPhase2Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Factor(factor, handler, param);}
|
|
|
void setEncoderPhase3Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Offset(offset, handler, param);}
|
|
|
void setEncoderIndexDistance(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderIndexDistance(pos, handler, param);}
|
|
|
void setEncoderPhase3Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Factor(factor, handler, param);}
|
|
|
void setCLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLProportionalGain(gain, handler, param);}
|
|
|
void setCLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLIntegratorGain(gain, handler, param);}
|
|
|
void setCLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLOutputFilter(tim, handler, param);}
|
|
|
void setCLCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tTimeLimit(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tTimeLimit(tim, handler, param);}
|
|
|
void setCLRegenMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setCLRegenMode(mode, handler, param);}
|
|
|
void setInitMode(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setInitMode(typ, handler, param);}
|
|
|
void setInitPulseLevel(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitPulseLevel(cur, handler, param);}
|
|
|
void setInitMaxCurrent(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitMaxCurrent(cur, handler, param);}
|
|
|
void setInitFinalPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitFinalPhase(cal, handler, param);}
|
|
|
void setInitTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setInitTime(tim, handler, param);}
|
|
|
void setInitCurrentRate(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitCurrentRate(cur, handler, param);}
|
|
|
void setInitPhaseRate(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitPhaseRate(cal, handler, param);}
|
|
|
void setInitInitialPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitInitialPhase(cal, handler, param);}
|
|
|
void setDriveFuseChecking(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setDriveFuseChecking(mask, handler, param);}
|
|
|
void setMotorTempChecking(dword val, DsaHandler handler, void *param = NULL) {DsaBase::setMotorTempChecking(val, handler, param);}
|
|
|
void setMonSourceType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceType(sidx, typ, handler, param);}
|
|
|
void setMonSourceIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceIndex(sidx, index, handler, param);}
|
|
|
void setMonDestIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonDestIndex(sidx, index, handler, param);}
|
|
|
void setMonOffset(int sidx, long offset, DsaHandler handler, void *param = NULL) {DsaBase::setMonOffset(sidx, offset, handler, param);}
|
|
|
void setMonGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setMonGain(sidx, gain, handler, param);}
|
|
|
void setXAnalogOffset(int sidx, double offset, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOffset(sidx, offset, handler, param);}
|
|
|
void setXAnalogGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogGain(sidx, gain, handler, param);}
|
|
|
void setSyncroInputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputMask(mask, handler, param);}
|
|
|
void setSyncroInputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputValue(mask, handler, param);}
|
|
|
void setSyncroOutputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputMask(mask, handler, param);}
|
|
|
void setSyncroOutputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputValue(mask, handler, param);}
|
|
|
void setSyncroStartTimeout(int tim, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroStartTimeout(tim, handler, param);}
|
|
|
void setDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setDigitalOutput(out, handler, param);}
|
|
|
void setXDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setXDigitalOutput(out, handler, param);}
|
|
|
void setXAnalogOutput1(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput1(out, handler, param);}
|
|
|
void setXAnalogOutput2(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput2(out, handler, param);}
|
|
|
void setXAnalogOutput3(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput3(out, handler, param);}
|
|
|
void setXAnalogOutput4(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput4(out, handler, param);}
|
|
|
void setAnalogOutput(double out, DsaHandler handler, void *param = NULL) {DsaBase::setAnalogOutput(out, handler, param);}
|
|
|
void setInterruptMask1(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask1(sidx, mask, handler, param);}
|
|
|
void setInterruptMask2(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask2(sidx, mask, handler, param);}
|
|
|
void setTriggerIrqMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIrqMask(mask, handler, param);}
|
|
|
void setTriggerIOMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIOMask(mask, handler, param);}
|
|
|
void setTriggerMapOffset(int offset, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapOffset(offset, handler, param);}
|
|
|
void setTriggerMapSize(int size, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapSize(size, handler, param);}
|
|
|
void setRealtimeEnabledGlobal(int enable, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledGlobal(enable, handler, param);}
|
|
|
void setRealtimeValidMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeValidMask(mask, handler, param);}
|
|
|
void setRealtimeEnabledMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledMask(mask, handler, param);}
|
|
|
void setRealtimePendingMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimePendingMask(mask, handler, param);}
|
|
|
void setEblBaudrate(long baud, DsaHandler handler, void *param = NULL) {DsaBase::setEblBaudrate(baud, handler, param);}
|
|
|
void setIndirectAxisNumber(int axis, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectAxisNumber(axis, handler, param);}
|
|
|
void setIndirectRegisterIdx(int idx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterIdx(idx, handler, param);}
|
|
|
void setIndirectRegisterSidx(int sidx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterSidx(sidx, handler, param);}
|
|
|
void setConcatenatedMvt(int concat, DsaHandler handler, void *param = NULL) {DsaBase::setConcatenatedMvt(concat, handler, param);}
|
|
|
void setProfileType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setProfileType(sidx, typ, handler, param);}
|
|
|
void setMvtLktNumber(int sidx, int number, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktNumber(sidx, number, handler, param);}
|
|
|
void setMvtLktTime(int sidx, double time, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktTime(sidx, time, handler, param);}
|
|
|
void setCameValue(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCameValue(factor, handler, param);}
|
|
|
void setBrakeDeceleration(double dec, DsaHandler handler, void *param = NULL) {DsaBase::setBrakeDeceleration(dec, handler, param);}
|
|
|
void setTargetPosition(int sidx, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTargetPosition(sidx, pos, handler, param);}
|
|
|
void setProfileVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setProfileVelocity(sidx, vel, handler, param);}
|
|
|
void setProfileAcceleration(int sidx, double acc, DsaHandler handler, void *param = NULL) {DsaBase::setProfileAcceleration(sidx, acc, handler, param);}
|
|
|
void setJerkTime(int sidx, double tim, DsaHandler handler, void *param = NULL) {DsaBase::setJerkTime(sidx, tim, handler, param);}
|
|
|
void setProfileDeceleration(int sidx, double dec, DsaHandler handler, void *param = NULL) {DsaBase::setProfileDeceleration(sidx, dec, handler, param);}
|
|
|
void setEndVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setEndVelocity(sidx, vel, handler, param);}
|
|
|
void setCtrlSourceType(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceType(typ, handler, param);}
|
|
|
void setCtrlSourceIndex(int index, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceIndex(index, handler, param);}
|
|
|
void setCtrlShiftFactor(int shift, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlShiftFactor(shift, handler, param);}
|
|
|
void setCtrlOffset(long offset, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlOffset(offset, handler, param);}
|
|
|
void setCtrlGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlGain(gain, handler, param);}
|
|
|
void setMotorKTFactor(double kt, DsaHandler handler, void *param = NULL) {DsaBase::setMotorKTFactor(kt, handler, param);}
|
|
|
|
|
|
/* register getters */
|
|
|
double getPLProportionalGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLProportionalGain(kind, timeout);}
|
|
|
void getPLProportionalGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLProportionalGain(gain, kind, timeout);}
|
|
|
double getPLSpeedFeedbackGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLSpeedFeedbackGain(kind, timeout);}
|
|
|
void getPLSpeedFeedbackGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLSpeedFeedbackGain(gain, kind, timeout);}
|
|
|
double getPLForceFeedbackGain1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLForceFeedbackGain1(kind, timeout);}
|
|
|
void getPLForceFeedbackGain1(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLForceFeedbackGain1(gain, kind, timeout);}
|
|
|
double getPLIntegratorGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLIntegratorGain(kind, timeout);}
|
|
|
void getPLIntegratorGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLIntegratorGain(gain, kind, timeout);}
|
|
|
double getPLAntiWindupGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLAntiWindupGain(kind, timeout);}
|
|
|
void getPLAntiWindupGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLAntiWindupGain(gain, kind, timeout);}
|
|
|
double getPLIntegratorLimitation(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLIntegratorLimitation(kind, timeout);}
|
|
|
void getPLIntegratorLimitation(double *limit, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLIntegratorLimitation(limit, kind, timeout);}
|
|
|
int getPLIntegratorMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLIntegratorMode(kind, timeout);}
|
|
|
void getPLIntegratorMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLIntegratorMode(mode, kind, timeout);}
|
|
|
double getPLSpeedFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLSpeedFilter(kind, timeout);}
|
|
|
void getPLSpeedFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLSpeedFilter(tim, kind, timeout);}
|
|
|
double getPLOutputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLOutputFilter(kind, timeout);}
|
|
|
void getPLOutputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLOutputFilter(tim, kind, timeout);}
|
|
|
double getCLInputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLInputFilter(kind, timeout);}
|
|
|
void getCLInputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLInputFilter(tim, kind, timeout);}
|
|
|
double getTtlSpecialFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTtlSpecialFilter(kind, timeout);}
|
|
|
void getTtlSpecialFilter(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTtlSpecialFilter(factor, kind, timeout);}
|
|
|
double getPLForceFeedbackGain2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLForceFeedbackGain2(kind, timeout);}
|
|
|
void getPLForceFeedbackGain2(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLForceFeedbackGain2(factor, kind, timeout);}
|
|
|
double getPLSpeedFeedfwdGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLSpeedFeedfwdGain(kind, timeout);}
|
|
|
void getPLSpeedFeedfwdGain(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLSpeedFeedfwdGain(factor, kind, timeout);}
|
|
|
double getPLAccFeedforwardGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLAccFeedforwardGain(kind, timeout);}
|
|
|
void getPLAccFeedforwardGain(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLAccFeedforwardGain(factor, kind, timeout);}
|
|
|
double getCLPhaseAdvanceFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLPhaseAdvanceFactor(kind, timeout);}
|
|
|
void getCLPhaseAdvanceFactor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLPhaseAdvanceFactor(factor, kind, timeout);}
|
|
|
double getAprInputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAprInputFilter(kind, timeout);}
|
|
|
void getAprInputFilter(double *time, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAprInputFilter(time, kind, timeout);}
|
|
|
double getCLPhaseAdvanceShift(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLPhaseAdvanceShift(kind, timeout);}
|
|
|
void getCLPhaseAdvanceShift(double *shift, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLPhaseAdvanceShift(shift, kind, timeout);}
|
|
|
double getMinPositionRangeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMinPositionRangeLimit(kind, timeout);}
|
|
|
void getMinPositionRangeLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMinPositionRangeLimit(pos, kind, timeout);}
|
|
|
double getMaxPositionRangeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxPositionRangeLimit(kind, timeout);}
|
|
|
void getMaxPositionRangeLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxPositionRangeLimit(pos, kind, timeout);}
|
|
|
double getMaxProfileVelocity(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxProfileVelocity(kind, timeout);}
|
|
|
void getMaxProfileVelocity(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxProfileVelocity(vel, kind, timeout);}
|
|
|
double getMaxAcceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxAcceleration(kind, timeout);}
|
|
|
void getMaxAcceleration(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxAcceleration(acc, kind, timeout);}
|
|
|
double getFollowingErrorWindow(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getFollowingErrorWindow(kind, timeout);}
|
|
|
void getFollowingErrorWindow(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getFollowingErrorWindow(pos, kind, timeout);}
|
|
|
double getVelocityErrorLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getVelocityErrorLimit(kind, timeout);}
|
|
|
void getVelocityErrorLimit(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getVelocityErrorLimit(vel, kind, timeout);}
|
|
|
int getSwitchLimitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSwitchLimitMode(kind, timeout);}
|
|
|
void getSwitchLimitMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSwitchLimitMode(mode, kind, timeout);}
|
|
|
int getEnableInputMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEnableInputMode(kind, timeout);}
|
|
|
void getEnableInputMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEnableInputMode(mode, kind, timeout);}
|
|
|
double getMinSoftPositionLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMinSoftPositionLimit(kind, timeout);}
|
|
|
void getMinSoftPositionLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMinSoftPositionLimit(pos, kind, timeout);}
|
|
|
double getMaxSoftPositionLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxSoftPositionLimit(kind, timeout);}
|
|
|
void getMaxSoftPositionLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxSoftPositionLimit(pos, kind, timeout);}
|
|
|
dword getProfileLimitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileLimitMode(kind, timeout);}
|
|
|
void getProfileLimitMode(dword *flags, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileLimitMode(flags, kind, timeout);}
|
|
|
dword getIOErrorEventMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIOErrorEventMask(kind, timeout);}
|
|
|
void getIOErrorEventMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIOErrorEventMask(mask, kind, timeout);}
|
|
|
double getPositionWindowTime(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionWindowTime(kind, timeout);}
|
|
|
void getPositionWindowTime(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionWindowTime(tim, kind, timeout);}
|
|
|
double getPositionWindow(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionWindow(kind, timeout);}
|
|
|
void getPositionWindow(double *win, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionWindow(win, kind, timeout);}
|
|
|
int getHomingMethod(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingMethod(kind, timeout);}
|
|
|
void getHomingMethod(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingMethod(mode, kind, timeout);}
|
|
|
double getHomingZeroSpeed(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingZeroSpeed(kind, timeout);}
|
|
|
void getHomingZeroSpeed(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingZeroSpeed(vel, kind, timeout);}
|
|
|
double getHomingAcceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingAcceleration(kind, timeout);}
|
|
|
void getHomingAcceleration(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingAcceleration(acc, kind, timeout);}
|
|
|
double getHomingFollowingLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFollowingLimit(kind, timeout);}
|
|
|
void getHomingFollowingLimit(double *win, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFollowingLimit(win, kind, timeout);}
|
|
|
double getHomingCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingCurrentLimit(kind, timeout);}
|
|
|
void getHomingCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingCurrentLimit(cur, kind, timeout);}
|
|
|
double getHomeOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomeOffset(kind, timeout);}
|
|
|
void getHomeOffset(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomeOffset(pos, kind, timeout);}
|
|
|
double getHomingFixedMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFixedMvt(kind, timeout);}
|
|
|
void getHomingFixedMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFixedMvt(pos, kind, timeout);}
|
|
|
double getHomingSwitchMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingSwitchMvt(kind, timeout);}
|
|
|
void getHomingSwitchMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingSwitchMvt(pos, kind, timeout);}
|
|
|
double getHomingIndexMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingIndexMvt(kind, timeout);}
|
|
|
void getHomingIndexMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingIndexMvt(pos, kind, timeout);}
|
|
|
int getHomingFineTuningMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFineTuningMode(kind, timeout);}
|
|
|
void getHomingFineTuningMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFineTuningMode(mode, kind, timeout);}
|
|
|
double getHomingFineTuningValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFineTuningValue(kind, timeout);}
|
|
|
void getHomingFineTuningValue(double *phase, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFineTuningValue(phase, kind, timeout);}
|
|
|
int getMotorPhaseCorrection(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMotorPhaseCorrection(kind, timeout);}
|
|
|
void getMotorPhaseCorrection(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMotorPhaseCorrection(mode, kind, timeout);}
|
|
|
double getSoftwareCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSoftwareCurrentLimit(kind, timeout);}
|
|
|
void getSoftwareCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSoftwareCurrentLimit(cur, kind, timeout);}
|
|
|
int getDriveControlMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveControlMode(kind, timeout);}
|
|
|
void getDriveControlMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveControlMode(mode, kind, timeout);}
|
|
|
int getDisplayMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDisplayMode(kind, timeout);}
|
|
|
void getDisplayMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDisplayMode(mode, kind, timeout);}
|
|
|
double getEncoderInversion(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderInversion(kind, timeout);}
|
|
|
void getEncoderInversion(double *invert, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderInversion(invert, kind, timeout);}
|
|
|
double getPdrStepValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPdrStepValue(kind, timeout);}
|
|
|
void getPdrStepValue(double *step, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPdrStepValue(step, kind, timeout);}
|
|
|
double getEncoderPhase1Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase1Offset(kind, timeout);}
|
|
|
void getEncoderPhase1Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase1Offset(offset, kind, timeout);}
|
|
|
double getEncoderPhase2Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase2Offset(kind, timeout);}
|
|
|
void getEncoderPhase2Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase2Offset(offset, kind, timeout);}
|
|
|
double getEncoderPhase1Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase1Factor(kind, timeout);}
|
|
|
void getEncoderPhase1Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase1Factor(factor, kind, timeout);}
|
|
|
double getEncoderPhase2Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase2Factor(kind, timeout);}
|
|
|
void getEncoderPhase2Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase2Factor(factor, kind, timeout);}
|
|
|
double getEncoderPhase3Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase3Offset(kind, timeout);}
|
|
|
void getEncoderPhase3Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase3Offset(offset, kind, timeout);}
|
|
|
double getEncoderIndexDistance(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderIndexDistance(kind, timeout);}
|
|
|
void getEncoderIndexDistance(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderIndexDistance(pos, kind, timeout);}
|
|
|
double getEncoderPhase3Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase3Factor(kind, timeout);}
|
|
|
void getEncoderPhase3Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase3Factor(factor, kind, timeout);}
|
|
|
double getCLProportionalGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLProportionalGain(kind, timeout);}
|
|
|
void getCLProportionalGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLProportionalGain(gain, kind, timeout);}
|
|
|
double getCLIntegratorGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLIntegratorGain(kind, timeout);}
|
|
|
void getCLIntegratorGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLIntegratorGain(gain, kind, timeout);}
|
|
|
double getCLOutputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLOutputFilter(kind, timeout);}
|
|
|
void getCLOutputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLOutputFilter(tim, kind, timeout);}
|
|
|
double getCLCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentLimit(kind, timeout);}
|
|
|
void getCLCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentLimit(cur, kind, timeout);}
|
|
|
double getCLI2tCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLI2tCurrentLimit(kind, timeout);}
|
|
|
void getCLI2tCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLI2tCurrentLimit(cur, kind, timeout);}
|
|
|
double getCLI2tTimeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLI2tTimeLimit(kind, timeout);}
|
|
|
void getCLI2tTimeLimit(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLI2tTimeLimit(tim, kind, timeout);}
|
|
|
int getCLRegenMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLRegenMode(kind, timeout);}
|
|
|
void getCLRegenMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLRegenMode(mode, kind, timeout);}
|
|
|
int getInitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitMode(kind, timeout);}
|
|
|
void getInitMode(int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitMode(typ, kind, timeout);}
|
|
|
double getInitPulseLevel(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitPulseLevel(kind, timeout);}
|
|
|
void getInitPulseLevel(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitPulseLevel(cur, kind, timeout);}
|
|
|
double getInitMaxCurrent(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitMaxCurrent(kind, timeout);}
|
|
|
void getInitMaxCurrent(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitMaxCurrent(cur, kind, timeout);}
|
|
|
double getInitFinalPhase(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitFinalPhase(kind, timeout);}
|
|
|
void getInitFinalPhase(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitFinalPhase(cal, kind, timeout);}
|
|
|
double getInitTime(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitTime(kind, timeout);}
|
|
|
void getInitTime(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitTime(tim, kind, timeout);}
|
|
|
double getInitCurrentRate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitCurrentRate(kind, timeout);}
|
|
|
void getInitCurrentRate(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitCurrentRate(cur, kind, timeout);}
|
|
|
double getInitPhaseRate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitPhaseRate(kind, timeout);}
|
|
|
void getInitPhaseRate(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitPhaseRate(cal, kind, timeout);}
|
|
|
double getInitInitialPhase(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitInitialPhase(kind, timeout);}
|
|
|
void getInitInitialPhase(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitInitialPhase(cal, kind, timeout);}
|
|
|
dword getDriveFuseChecking(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveFuseChecking(kind, timeout);}
|
|
|
void getDriveFuseChecking(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveFuseChecking(mask, kind, timeout);}
|
|
|
dword getMotorTempChecking(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMotorTempChecking(kind, timeout);}
|
|
|
void getMotorTempChecking(dword *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMotorTempChecking(val, kind, timeout);}
|
|
|
int getMonSourceType(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonSourceType(sidx, kind, timeout);}
|
|
|
void getMonSourceType(int sidx, int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonSourceType(sidx, typ, kind, timeout);}
|
|
|
int getMonSourceIndex(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonSourceIndex(sidx, kind, timeout);}
|
|
|
void getMonSourceIndex(int sidx, int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonSourceIndex(sidx, index, kind, timeout);}
|
|
|
int getMonDestIndex(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonDestIndex(sidx, kind, timeout);}
|
|
|
void getMonDestIndex(int sidx, int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonDestIndex(sidx, index, kind, timeout);}
|
|
|
long getMonOffset(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonOffset(sidx, kind, timeout);}
|
|
|
void getMonOffset(int sidx, long *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonOffset(sidx, offset, kind, timeout);}
|
|
|
double getMonGain(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonGain(sidx, kind, timeout);}
|
|
|
void getMonGain(int sidx, double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonGain(sidx, gain, kind, timeout);}
|
|
|
double getXAnalogOffset(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOffset(sidx, kind, timeout);}
|
|
|
void getXAnalogOffset(int sidx, double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOffset(sidx, offset, kind, timeout);}
|
|
|
double getXAnalogGain(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogGain(sidx, kind, timeout);}
|
|
|
void getXAnalogGain(int sidx, double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogGain(sidx, gain, kind, timeout);}
|
|
|
dword getSyncroInputMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroInputMask(kind, timeout);}
|
|
|
void getSyncroInputMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroInputMask(mask, kind, timeout);}
|
|
|
dword getSyncroInputValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroInputValue(kind, timeout);}
|
|
|
void getSyncroInputValue(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroInputValue(mask, kind, timeout);}
|
|
|
dword getSyncroOutputMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroOutputMask(kind, timeout);}
|
|
|
void getSyncroOutputMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroOutputMask(mask, kind, timeout);}
|
|
|
dword getSyncroOutputValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroOutputValue(kind, timeout);}
|
|
|
void getSyncroOutputValue(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroOutputValue(mask, kind, timeout);}
|
|
|
int getSyncroStartTimeout(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroStartTimeout(kind, timeout);}
|
|
|
void getSyncroStartTimeout(int *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroStartTimeout(tim, kind, timeout);}
|
|
|
dword getDigitalOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDigitalOutput(kind, timeout);}
|
|
|
void getDigitalOutput(dword *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDigitalOutput(out, kind, timeout);}
|
|
|
dword getXDigitalOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXDigitalOutput(kind, timeout);}
|
|
|
void getXDigitalOutput(dword *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXDigitalOutput(out, kind, timeout);}
|
|
|
double getXAnalogOutput1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput1(kind, timeout);}
|
|
|
void getXAnalogOutput1(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput1(out, kind, timeout);}
|
|
|
double getXAnalogOutput2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput2(kind, timeout);}
|
|
|
void getXAnalogOutput2(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput2(out, kind, timeout);}
|
|
|
double getXAnalogOutput3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput3(kind, timeout);}
|
|
|
void getXAnalogOutput3(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput3(out, kind, timeout);}
|
|
|
double getXAnalogOutput4(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput4(kind, timeout);}
|
|
|
void getXAnalogOutput4(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput4(out, kind, timeout);}
|
|
|
double getAnalogOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAnalogOutput(kind, timeout);}
|
|
|
void getAnalogOutput(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAnalogOutput(out, kind, timeout);}
|
|
|
dword getInterruptMask1(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInterruptMask1(sidx, kind, timeout);}
|
|
|
void getInterruptMask1(int sidx, dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInterruptMask1(sidx, mask, kind, timeout);}
|
|
|
dword getInterruptMask2(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInterruptMask2(sidx, kind, timeout);}
|
|
|
void getInterruptMask2(int sidx, dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInterruptMask2(sidx, mask, kind, timeout);}
|
|
|
dword getTriggerIrqMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerIrqMask(kind, timeout);}
|
|
|
void getTriggerIrqMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerIrqMask(mask, kind, timeout);}
|
|
|
dword getTriggerIOMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerIOMask(kind, timeout);}
|
|
|
void getTriggerIOMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerIOMask(mask, kind, timeout);}
|
|
|
int getTriggerMapOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerMapOffset(kind, timeout);}
|
|
|
void getTriggerMapOffset(int *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerMapOffset(offset, kind, timeout);}
|
|
|
int getTriggerMapSize(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerMapSize(kind, timeout);}
|
|
|
void getTriggerMapSize(int *size, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerMapSize(size, kind, timeout);}
|
|
|
int getRealtimeEnabledGlobal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimeEnabledGlobal(kind, timeout);}
|
|
|
void getRealtimeEnabledGlobal(int *enable, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimeEnabledGlobal(enable, kind, timeout);}
|
|
|
dword getRealtimeValidMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimeValidMask(kind, timeout);}
|
|
|
void getRealtimeValidMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimeValidMask(mask, kind, timeout);}
|
|
|
dword getRealtimeEnabledMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimeEnabledMask(kind, timeout);}
|
|
|
void getRealtimeEnabledMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimeEnabledMask(mask, kind, timeout);}
|
|
|
dword getRealtimePendingMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimePendingMask(kind, timeout);}
|
|
|
void getRealtimePendingMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimePendingMask(mask, kind, timeout);}
|
|
|
long getEblBaudrate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEblBaudrate(kind, timeout);}
|
|
|
void getEblBaudrate(long *baud, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEblBaudrate(baud, kind, timeout);}
|
|
|
int getIndirectAxisNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIndirectAxisNumber(kind, timeout);}
|
|
|
void getIndirectAxisNumber(int *axis, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIndirectAxisNumber(axis, kind, timeout);}
|
|
|
int getIndirectRegisterIdx(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIndirectRegisterIdx(kind, timeout);}
|
|
|
void getIndirectRegisterIdx(int *idx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIndirectRegisterIdx(idx, kind, timeout);}
|
|
|
int getIndirectRegisterSidx(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIndirectRegisterSidx(kind, timeout);}
|
|
|
void getIndirectRegisterSidx(int *sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIndirectRegisterSidx(sidx, kind, timeout);}
|
|
|
int getConcatenatedMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getConcatenatedMvt(kind, timeout);}
|
|
|
void getConcatenatedMvt(int *concat, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getConcatenatedMvt(concat, kind, timeout);}
|
|
|
int getProfileType(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileType(sidx, kind, timeout);}
|
|
|
void getProfileType(int sidx, int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileType(sidx, typ, kind, timeout);}
|
|
|
int getMvtLktNumber(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMvtLktNumber(sidx, kind, timeout);}
|
|
|
void getMvtLktNumber(int sidx, int *number, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMvtLktNumber(sidx, number, kind, timeout);}
|
|
|
double getMvtLktTime(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMvtLktTime(sidx, kind, timeout);}
|
|
|
void getMvtLktTime(int sidx, double *time, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMvtLktTime(sidx, time, kind, timeout);}
|
|
|
double getCameValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCameValue(kind, timeout);}
|
|
|
void getCameValue(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCameValue(factor, kind, timeout);}
|
|
|
double getBrakeDeceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getBrakeDeceleration(kind, timeout);}
|
|
|
void getBrakeDeceleration(double *dec, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getBrakeDeceleration(dec, kind, timeout);}
|
|
|
double getTargetPosition(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTargetPosition(sidx, kind, timeout);}
|
|
|
void getTargetPosition(int sidx, double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTargetPosition(sidx, pos, kind, timeout);}
|
|
|
double getProfileVelocity(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileVelocity(sidx, kind, timeout);}
|
|
|
void getProfileVelocity(int sidx, double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileVelocity(sidx, vel, kind, timeout);}
|
|
|
double getProfileAcceleration(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileAcceleration(sidx, kind, timeout);}
|
|
|
void getProfileAcceleration(int sidx, double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileAcceleration(sidx, acc, kind, timeout);}
|
|
|
double getJerkTime(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getJerkTime(sidx, kind, timeout);}
|
|
|
void getJerkTime(int sidx, double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getJerkTime(sidx, tim, kind, timeout);}
|
|
|
double getProfileDeceleration(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileDeceleration(sidx, kind, timeout);}
|
|
|
void getProfileDeceleration(int sidx, double *dec, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileDeceleration(sidx, dec, kind, timeout);}
|
|
|
double getEndVelocity(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEndVelocity(sidx, kind, timeout);}
|
|
|
void getEndVelocity(int sidx, double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEndVelocity(sidx, vel, kind, timeout);}
|
|
|
int getCtrlSourceType(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlSourceType(kind, timeout);}
|
|
|
void getCtrlSourceType(int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlSourceType(typ, kind, timeout);}
|
|
|
int getCtrlSourceIndex(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlSourceIndex(kind, timeout);}
|
|
|
void getCtrlSourceIndex(int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlSourceIndex(index, kind, timeout);}
|
|
|
int getCtrlShiftFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlShiftFactor(kind, timeout);}
|
|
|
void getCtrlShiftFactor(int *shift, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlShiftFactor(shift, kind, timeout);}
|
|
|
long getCtrlOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlOffset(kind, timeout);}
|
|
|
void getCtrlOffset(long *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlOffset(offset, kind, timeout);}
|
|
|
double getCtrlGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlGain(kind, timeout);}
|
|
|
void getCtrlGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlGain(gain, kind, timeout);}
|
|
|
double getMotorKTFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMotorKTFactor(kind, timeout);}
|
|
|
void getMotorKTFactor(double *kt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMotorKTFactor(kt, kind, timeout);}
|
|
|
double getPositionCtrlError(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionCtrlError(kind, timeout);}
|
|
|
void getPositionCtrlError(double *err, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionCtrlError(err, kind, timeout);}
|
|
|
double getPositionMaxError(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionMaxError(kind, timeout);}
|
|
|
void getPositionMaxError(double *err, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionMaxError(err, kind, timeout);}
|
|
|
double getPositionDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionDemandValue(kind, timeout);}
|
|
|
void getPositionDemandValue(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionDemandValue(pos, kind, timeout);}
|
|
|
double getPositionActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionActualValue(kind, timeout);}
|
|
|
void getPositionActualValue(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionActualValue(pos, kind, timeout);}
|
|
|
double getVelocityDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getVelocityDemandValue(kind, timeout);}
|
|
|
void getVelocityDemandValue(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getVelocityDemandValue(vel, kind, timeout);}
|
|
|
double getVelocityActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getVelocityActualValue(kind, timeout);}
|
|
|
void getVelocityActualValue(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getVelocityActualValue(vel, kind, timeout);}
|
|
|
double getAccDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAccDemandValue(kind, timeout);}
|
|
|
void getAccDemandValue(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAccDemandValue(acc, kind, timeout);}
|
|
|
double getAccActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAccActualValue(kind, timeout);}
|
|
|
void getAccActualValue(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAccActualValue(acc, kind, timeout);}
|
|
|
double getRefDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRefDemandValue(kind, timeout);}
|
|
|
void getRefDemandValue(double *ref, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRefDemandValue(ref, kind, timeout);}
|
|
|
dword getDriveControlMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveControlMask(kind, timeout);}
|
|
|
void getDriveControlMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveControlMask(mask, kind, timeout);}
|
|
|
double getCLCurrentPhase1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentPhase1(kind, timeout);}
|
|
|
void getCLCurrentPhase1(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentPhase1(cur, kind, timeout);}
|
|
|
double getCLCurrentPhase2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentPhase2(kind, timeout);}
|
|
|
void getCLCurrentPhase2(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentPhase2(cur, kind, timeout);}
|
|
|
double getCLCurrentPhase3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentPhase3(kind, timeout);}
|
|
|
void getCLCurrentPhase3(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentPhase3(cur, kind, timeout);}
|
|
|
double getCLLktPhase1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLLktPhase1(kind, timeout);}
|
|
|
void getCLLktPhase1(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLLktPhase1(lkt, kind, timeout);}
|
|
|
double getCLLktPhase2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLLktPhase2(kind, timeout);}
|
|
|
void getCLLktPhase2(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLLktPhase2(lkt, kind, timeout);}
|
|
|
double getCLLktPhase3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLLktPhase3(kind, timeout);}
|
|
|
void getCLLktPhase3(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLLktPhase3(lkt, kind, timeout);}
|
|
|
double getCLDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLDemandValue(kind, timeout);}
|
|
|
void getCLDemandValue(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLDemandValue(cur, kind, timeout);}
|
|
|
double getCLActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLActualValue(kind, timeout);}
|
|
|
void getCLActualValue(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLActualValue(cur, kind, timeout);}
|
|
|
double getEncoderSineSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderSineSignal(kind, timeout);}
|
|
|
void getEncoderSineSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderSineSignal(val, kind, timeout);}
|
|
|
double getEncoderCosineSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderCosineSignal(kind, timeout);}
|
|
|
void getEncoderCosineSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderCosineSignal(val, kind, timeout);}
|
|
|
double getEncoderIndexSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderIndexSignal(kind, timeout);}
|
|
|
void getEncoderIndexSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderIndexSignal(val, kind, timeout);}
|
|
|
double getEncoderHall1Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHall1Signal(kind, timeout);}
|
|
|
void getEncoderHall1Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHall1Signal(val, kind, timeout);}
|
|
|
double getEncoderHall2Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHall2Signal(kind, timeout);}
|
|
|
void getEncoderHall2Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHall2Signal(val, kind, timeout);}
|
|
|
double getEncoderHall3Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHall3Signal(kind, timeout);}
|
|
|
void getEncoderHall3Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHall3Signal(val, kind, timeout);}
|
|
|
dword getEncoderHallDigSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHallDigSignal(kind, timeout);}
|
|
|
void getEncoderHallDigSignal(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHallDigSignal(mask, kind, timeout);}
|
|
|
dword getDigitalInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDigitalInput(kind, timeout);}
|
|
|
void getDigitalInput(dword *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDigitalInput(inp, kind, timeout);}
|
|
|
double getAnalogInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAnalogInput(kind, timeout);}
|
|
|
void getAnalogInput(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAnalogInput(inp, kind, timeout);}
|
|
|
dword getXDigitalInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXDigitalInput(kind, timeout);}
|
|
|
void getXDigitalInput(dword *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXDigitalInput(inp, kind, timeout);}
|
|
|
double getXAnalogInput1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput1(kind, timeout);}
|
|
|
void getXAnalogInput1(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput1(inp, kind, timeout);}
|
|
|
double getXAnalogInput2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput2(kind, timeout);}
|
|
|
void getXAnalogInput2(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput2(inp, kind, timeout);}
|
|
|
double getXAnalogInput3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput3(kind, timeout);}
|
|
|
void getXAnalogInput3(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput3(inp, kind, timeout);}
|
|
|
double getXAnalogInput4(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput4(kind, timeout);}
|
|
|
void getXAnalogInput4(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput4(inp, kind, timeout);}
|
|
|
dword getDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveStatus1(kind, timeout);}
|
|
|
void getDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveStatus1(mask, kind, timeout);}
|
|
|
dword getDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveStatus2(kind, timeout);}
|
|
|
void getDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveStatus2(mask, kind, timeout);}
|
|
|
double getCLI2tValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLI2tValue(kind, timeout);}
|
|
|
void getCLI2tValue(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLI2tValue(val, kind, timeout);}
|
|
|
int getAxisNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAxisNumber(kind, timeout);}
|
|
|
void getAxisNumber(int *num, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAxisNumber(num, kind, timeout);}
|
|
|
int getDaisyChainNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDaisyChainNumber(kind, timeout);}
|
|
|
void getDaisyChainNumber(int *num, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDaisyChainNumber(num, kind, timeout);}
|
|
|
double getDriveTemperature(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveTemperature(kind, timeout);}
|
|
|
void getDriveTemperature(double *temp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveTemperature(temp, kind, timeout);}
|
|
|
dword getDriveMaskValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveMaskValue(kind, timeout);}
|
|
|
void getDriveMaskValue(dword *str, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveMaskValue(str, kind, timeout);}
|
|
|
dword getDriveDisplay(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveDisplay(sidx, kind, timeout);}
|
|
|
void getDriveDisplay(int sidx, dword *str, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveDisplay(sidx, str, kind, timeout);}
|
|
|
long getDriveSequenceLine(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveSequenceLine(kind, timeout);}
|
|
|
void getDriveSequenceLine(long *line, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveSequenceLine(line, kind, timeout);}
|
|
|
dword getDriveFuseStatus(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveFuseStatus(kind, timeout);}
|
|
|
void getDriveFuseStatus(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveFuseStatus(mask, kind, timeout);}
|
|
|
dword getIrqDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIrqDriveStatus1(kind, timeout);}
|
|
|
void getIrqDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIrqDriveStatus1(mask, kind, timeout);}
|
|
|
dword getIrqDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIrqDriveStatus2(kind, timeout);}
|
|
|
void getIrqDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIrqDriveStatus2(mask, kind, timeout);}
|
|
|
dword getAckDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAckDriveStatus1(kind, timeout);}
|
|
|
void getAckDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAckDriveStatus1(mask, kind, timeout);}
|
|
|
dword getAckDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAckDriveStatus2(kind, timeout);}
|
|
|
void getAckDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAckDriveStatus2(mask, kind, timeout);}
|
|
|
dword getIrqPendingAxisMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIrqPendingAxisMask(kind, timeout);}
|
|
|
void getIrqPendingAxisMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIrqPendingAxisMask(mask, kind, timeout);}
|
|
|
dword getCanFeedback1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCanFeedback1(kind, timeout);}
|
|
|
void getCanFeedback1(dword *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCanFeedback1(val1, kind, timeout);}
|
|
|
dword getCanFeedback2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCanFeedback2(kind, timeout);}
|
|
|
void getCanFeedback2(dword *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCanFeedback2(val1, kind, timeout);}
|
|
|
int getNbAvailableSlot(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getNbAvailableSlot(kind, timeout);}
|
|
|
void getNbAvailableSlot(int *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getNbAvailableSlot(val1, kind, timeout);}
|
|
|
|
|
|
void getPLProportionalGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLProportionalGain(kind, handler, param);}
|
|
|
void getPLProportionalGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLProportionalGain(handler, param);}
|
|
|
void getPLSpeedFeedbackGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedbackGain(kind, handler, param);}
|
|
|
void getPLSpeedFeedbackGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedbackGain(handler, param);}
|
|
|
void getPLForceFeedbackGain1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain1(kind, handler, param);}
|
|
|
void getPLForceFeedbackGain1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain1(handler, param);}
|
|
|
void getPLIntegratorGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorGain(kind, handler, param);}
|
|
|
void getPLIntegratorGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorGain(handler, param);}
|
|
|
void getPLAntiWindupGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAntiWindupGain(kind, handler, param);}
|
|
|
void getPLAntiWindupGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAntiWindupGain(handler, param);}
|
|
|
void getPLIntegratorLimitation(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorLimitation(kind, handler, param);}
|
|
|
void getPLIntegratorLimitation(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorLimitation(handler, param);}
|
|
|
void getPLIntegratorMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getPLIntegratorMode(kind, handler, param);}
|
|
|
void getPLIntegratorMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getPLIntegratorMode(handler, param);}
|
|
|
void getPLSpeedFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFilter(kind, handler, param);}
|
|
|
void getPLSpeedFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFilter(handler, param);}
|
|
|
void getPLOutputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLOutputFilter(kind, handler, param);}
|
|
|
void getPLOutputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLOutputFilter(handler, param);}
|
|
|
void getCLInputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLInputFilter(kind, handler, param);}
|
|
|
void getCLInputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLInputFilter(handler, param);}
|
|
|
void getTtlSpecialFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTtlSpecialFilter(kind, handler, param);}
|
|
|
void getTtlSpecialFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTtlSpecialFilter(handler, param);}
|
|
|
void getPLForceFeedbackGain2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain2(kind, handler, param);}
|
|
|
void getPLForceFeedbackGain2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain2(handler, param);}
|
|
|
void getPLSpeedFeedfwdGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedfwdGain(kind, handler, param);}
|
|
|
void getPLSpeedFeedfwdGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedfwdGain(handler, param);}
|
|
|
void getPLAccFeedforwardGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAccFeedforwardGain(kind, handler, param);}
|
|
|
void getPLAccFeedforwardGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAccFeedforwardGain(handler, param);}
|
|
|
void getCLPhaseAdvanceFactor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceFactor(kind, handler, param);}
|
|
|
void getCLPhaseAdvanceFactor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceFactor(handler, param);}
|
|
|
void getAprInputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAprInputFilter(kind, handler, param);}
|
|
|
void getAprInputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAprInputFilter(handler, param);}
|
|
|
void getCLPhaseAdvanceShift(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceShift(kind, handler, param);}
|
|
|
void getCLPhaseAdvanceShift(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceShift(handler, param);}
|
|
|
void getMinPositionRangeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinPositionRangeLimit(kind, handler, param);}
|
|
|
void getMinPositionRangeLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinPositionRangeLimit(handler, param);}
|
|
|
void getMaxPositionRangeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxPositionRangeLimit(kind, handler, param);}
|
|
|
void getMaxPositionRangeLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxPositionRangeLimit(handler, param);}
|
|
|
void getMaxProfileVelocity(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxProfileVelocity(kind, handler, param);}
|
|
|
void getMaxProfileVelocity(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxProfileVelocity(handler, param);}
|
|
|
void getMaxAcceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxAcceleration(kind, handler, param);}
|
|
|
void getMaxAcceleration(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxAcceleration(handler, param);}
|
|
|
void getFollowingErrorWindow(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFollowingErrorWindow(kind, handler, param);}
|
|
|
void getFollowingErrorWindow(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFollowingErrorWindow(handler, param);}
|
|
|
void getVelocityErrorLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityErrorLimit(kind, handler, param);}
|
|
|
void getVelocityErrorLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityErrorLimit(handler, param);}
|
|
|
void getSwitchLimitMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getSwitchLimitMode(kind, handler, param);}
|
|
|
void getSwitchLimitMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getSwitchLimitMode(handler, param);}
|
|
|
void getEnableInputMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getEnableInputMode(kind, handler, param);}
|
|
|
void getEnableInputMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getEnableInputMode(handler, param);}
|
|
|
void getMinSoftPositionLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinSoftPositionLimit(kind, handler, param);}
|
|
|
void getMinSoftPositionLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinSoftPositionLimit(handler, param);}
|
|
|
void getMaxSoftPositionLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxSoftPositionLimit(kind, handler, param);}
|
|
|
void getMaxSoftPositionLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxSoftPositionLimit(handler, param);}
|
|
|
void getProfileLimitMode(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getProfileLimitMode(kind, handler, param);}
|
|
|
void getProfileLimitMode(DsaDWordHandler handler, void *param = NULL) {DsaBase::getProfileLimitMode(handler, param);}
|
|
|
void getIOErrorEventMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIOErrorEventMask(kind, handler, param);}
|
|
|
void getIOErrorEventMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIOErrorEventMask(handler, param);}
|
|
|
void getPositionWindowTime(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindowTime(kind, handler, param);}
|
|
|
void getPositionWindowTime(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindowTime(handler, param);}
|
|
|
void getPositionWindow(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindow(kind, handler, param);}
|
|
|
void getPositionWindow(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindow(handler, param);}
|
|
|
void getHomingMethod(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingMethod(kind, handler, param);}
|
|
|
void getHomingMethod(DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingMethod(handler, param);}
|
|
|
void getHomingZeroSpeed(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingZeroSpeed(kind, handler, param);}
|
|
|
void getHomingZeroSpeed(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingZeroSpeed(handler, param);}
|
|
|
void getHomingAcceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingAcceleration(kind, handler, param);}
|
|
|
void getHomingAcceleration(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingAcceleration(handler, param);}
|
|
|
void getHomingFollowingLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFollowingLimit(kind, handler, param);}
|
|
|
void getHomingFollowingLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFollowingLimit(handler, param);}
|
|
|
void getHomingCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingCurrentLimit(kind, handler, param);}
|
|
|
void getHomingCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingCurrentLimit(handler, param);}
|
|
|
void getHomeOffset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomeOffset(kind, handler, param);}
|
|
|
void getHomeOffset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomeOffset(handler, param);}
|
|
|
void getHomingFixedMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFixedMvt(kind, handler, param);}
|
|
|
void getHomingFixedMvt(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFixedMvt(handler, param);}
|
|
|
void getHomingSwitchMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingSwitchMvt(kind, handler, param);}
|
|
|
void getHomingSwitchMvt(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingSwitchMvt(handler, param);}
|
|
|
void getHomingIndexMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingIndexMvt(kind, handler, param);}
|
|
|
void getHomingIndexMvt(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingIndexMvt(handler, param);}
|
|
|
void getHomingFineTuningMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningMode(kind, handler, param);}
|
|
|
void getHomingFineTuningMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningMode(handler, param);}
|
|
|
void getHomingFineTuningValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningValue(kind, handler, param);}
|
|
|
void getHomingFineTuningValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningValue(handler, param);}
|
|
|
void getMotorPhaseCorrection(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMotorPhaseCorrection(kind, handler, param);}
|
|
|
void getMotorPhaseCorrection(DsaIntHandler handler, void *param = NULL) {DsaBase::getMotorPhaseCorrection(handler, param);}
|
|
|
void getSoftwareCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getSoftwareCurrentLimit(kind, handler, param);}
|
|
|
void getSoftwareCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getSoftwareCurrentLimit(handler, param);}
|
|
|
void getDriveControlMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getDriveControlMode(kind, handler, param);}
|
|
|
void getDriveControlMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getDriveControlMode(handler, param);}
|
|
|
void getDisplayMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getDisplayMode(kind, handler, param);}
|
|
|
void getDisplayMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getDisplayMode(handler, param);}
|
|
|
void getEncoderInversion(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderInversion(kind, handler, param);}
|
|
|
void getEncoderInversion(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderInversion(handler, param);}
|
|
|
void getPdrStepValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPdrStepValue(kind, handler, param);}
|
|
|
void getPdrStepValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPdrStepValue(handler, param);}
|
|
|
void getEncoderPhase1Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Offset(kind, handler, param);}
|
|
|
void getEncoderPhase1Offset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Offset(handler, param);}
|
|
|
void getEncoderPhase2Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Offset(kind, handler, param);}
|
|
|
void getEncoderPhase2Offset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Offset(handler, param);}
|
|
|
void getEncoderPhase1Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Factor(kind, handler, param);}
|
|
|
void getEncoderPhase1Factor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Factor(handler, param);}
|
|
|
void getEncoderPhase2Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Factor(kind, handler, param);}
|
|
|
void getEncoderPhase2Factor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Factor(handler, param);}
|
|
|
void getEncoderPhase3Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Offset(kind, handler, param);}
|
|
|
void getEncoderPhase3Offset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Offset(handler, param);}
|
|
|
void getEncoderIndexDistance(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexDistance(kind, handler, param);}
|
|
|
void getEncoderIndexDistance(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexDistance(handler, param);}
|
|
|
void getEncoderPhase3Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Factor(kind, handler, param);}
|
|
|
void getEncoderPhase3Factor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Factor(handler, param);}
|
|
|
void getCLProportionalGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLProportionalGain(kind, handler, param);}
|
|
|
void getCLProportionalGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLProportionalGain(handler, param);}
|
|
|
void getCLIntegratorGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLIntegratorGain(kind, handler, param);}
|
|
|
void getCLIntegratorGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLIntegratorGain(handler, param);}
|
|
|
void getCLOutputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLOutputFilter(kind, handler, param);}
|
|
|
void getCLOutputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLOutputFilter(handler, param);}
|
|
|
void getCLCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentLimit(kind, handler, param);}
|
|
|
void getCLCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentLimit(handler, param);}
|
|
|
void getCLI2tCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tCurrentLimit(kind, handler, param);}
|
|
|
void getCLI2tCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tCurrentLimit(handler, param);}
|
|
|
void getCLI2tTimeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tTimeLimit(kind, handler, param);}
|
|
|
void getCLI2tTimeLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tTimeLimit(handler, param);}
|
|
|
void getCLRegenMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCLRegenMode(kind, handler, param);}
|
|
|
void getCLRegenMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getCLRegenMode(handler, param);}
|
|
|
void getInitMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getInitMode(kind, handler, param);}
|
|
|
void getInitMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getInitMode(handler, param);}
|
|
|
void getInitPulseLevel(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPulseLevel(kind, handler, param);}
|
|
|
void getInitPulseLevel(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPulseLevel(handler, param);}
|
|
|
void getInitMaxCurrent(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitMaxCurrent(kind, handler, param);}
|
|
|
void getInitMaxCurrent(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitMaxCurrent(handler, param);}
|
|
|
void getInitFinalPhase(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitFinalPhase(kind, handler, param);}
|
|
|
void getInitFinalPhase(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitFinalPhase(handler, param);}
|
|
|
void getInitTime(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitTime(kind, handler, param);}
|
|
|
void getInitTime(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitTime(handler, param);}
|
|
|
void getInitCurrentRate(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitCurrentRate(kind, handler, param);}
|
|
|
void getInitCurrentRate(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitCurrentRate(handler, param);}
|
|
|
void getInitPhaseRate(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPhaseRate(kind, handler, param);}
|
|
|
void getInitPhaseRate(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPhaseRate(handler, param);}
|
|
|
void getInitInitialPhase(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitInitialPhase(kind, handler, param);}
|
|
|
void getInitInitialPhase(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitInitialPhase(handler, param);}
|
|
|
void getDriveFuseChecking(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseChecking(kind, handler, param);}
|
|
|
void getDriveFuseChecking(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseChecking(handler, param);}
|
|
|
void getMotorTempChecking(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getMotorTempChecking(kind, handler, param);}
|
|
|
void getMotorTempChecking(DsaDWordHandler handler, void *param = NULL) {DsaBase::getMotorTempChecking(handler, param);}
|
|
|
void getMonSourceType(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceType(sidx, kind, handler, param);}
|
|
|
void getMonSourceType(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceType(sidx, handler, param);}
|
|
|
void getMonSourceIndex(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceIndex(sidx, kind, handler, param);}
|
|
|
void getMonSourceIndex(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceIndex(sidx, handler, param);}
|
|
|
void getMonDestIndex(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonDestIndex(sidx, kind, handler, param);}
|
|
|
void getMonDestIndex(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonDestIndex(sidx, handler, param);}
|
|
|
void getMonOffset(int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getMonOffset(sidx, kind, handler, param);}
|
|
|
void getMonOffset(int sidx, DsaLongHandler handler, void *param = NULL) {DsaBase::getMonOffset(sidx, handler, param);}
|
|
|
void getMonGain(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMonGain(sidx, kind, handler, param);}
|
|
|
void getMonGain(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMonGain(sidx, handler, param);}
|
|
|
void getXAnalogOffset(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOffset(sidx, kind, handler, param);}
|
|
|
void getXAnalogOffset(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOffset(sidx, handler, param);}
|
|
|
void getXAnalogGain(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogGain(sidx, kind, handler, param);}
|
|
|
void getXAnalogGain(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogGain(sidx, handler, param);}
|
|
|
void getSyncroInputMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputMask(kind, handler, param);}
|
|
|
void getSyncroInputMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputMask(handler, param);}
|
|
|
void getSyncroInputValue(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputValue(kind, handler, param);}
|
|
|
void getSyncroInputValue(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputValue(handler, param);}
|
|
|
void getSyncroOutputMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputMask(kind, handler, param);}
|
|
|
void getSyncroOutputMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputMask(handler, param);}
|
|
|
void getSyncroOutputValue(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputValue(kind, handler, param);}
|
|
|
void getSyncroOutputValue(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputValue(handler, param);}
|
|
|
void getSyncroStartTimeout(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getSyncroStartTimeout(kind, handler, param);}
|
|
|
void getSyncroStartTimeout(DsaIntHandler handler, void *param = NULL) {DsaBase::getSyncroStartTimeout(handler, param);}
|
|
|
void getDigitalOutput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalOutput(kind, handler, param);}
|
|
|
void getDigitalOutput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalOutput(handler, param);}
|
|
|
void getXDigitalOutput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalOutput(kind, handler, param);}
|
|
|
void getXDigitalOutput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalOutput(handler, param);}
|
|
|
void getXAnalogOutput1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput1(kind, handler, param);}
|
|
|
void getXAnalogOutput1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput1(handler, param);}
|
|
|
void getXAnalogOutput2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput2(kind, handler, param);}
|
|
|
void getXAnalogOutput2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput2(handler, param);}
|
|
|
void getXAnalogOutput3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput3(kind, handler, param);}
|
|
|
void getXAnalogOutput3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput3(handler, param);}
|
|
|
void getXAnalogOutput4(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput4(kind, handler, param);}
|
|
|
void getXAnalogOutput4(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput4(handler, param);}
|
|
|
void getAnalogOutput(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogOutput(kind, handler, param);}
|
|
|
void getAnalogOutput(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogOutput(handler, param);}
|
|
|
void getInterruptMask1(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask1(sidx, kind, handler, param);}
|
|
|
void getInterruptMask1(int sidx, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask1(sidx, handler, param);}
|
|
|
void getInterruptMask2(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask2(sidx, kind, handler, param);}
|
|
|
void getInterruptMask2(int sidx, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask2(sidx, handler, param);}
|
|
|
void getTriggerIrqMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIrqMask(kind, handler, param);}
|
|
|
void getTriggerIrqMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIrqMask(handler, param);}
|
|
|
void getTriggerIOMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIOMask(kind, handler, param);}
|
|
|
void getTriggerIOMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIOMask(handler, param);}
|
|
|
void getTriggerMapOffset(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapOffset(kind, handler, param);}
|
|
|
void getTriggerMapOffset(DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapOffset(handler, param);}
|
|
|
void getTriggerMapSize(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapSize(kind, handler, param);}
|
|
|
void getTriggerMapSize(DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapSize(handler, param);}
|
|
|
void getRealtimeEnabledGlobal(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledGlobal(kind, handler, param);}
|
|
|
void getRealtimeEnabledGlobal(DsaIntHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledGlobal(handler, param);}
|
|
|
void getRealtimeValidMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeValidMask(kind, handler, param);}
|
|
|
void getRealtimeValidMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeValidMask(handler, param);}
|
|
|
void getRealtimeEnabledMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledMask(kind, handler, param);}
|
|
|
void getRealtimeEnabledMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledMask(handler, param);}
|
|
|
void getRealtimePendingMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimePendingMask(kind, handler, param);}
|
|
|
void getRealtimePendingMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimePendingMask(handler, param);}
|
|
|
void getEblBaudrate(int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getEblBaudrate(kind, handler, param);}
|
|
|
void getEblBaudrate(DsaLongHandler handler, void *param = NULL) {DsaBase::getEblBaudrate(handler, param);}
|
|
|
void getIndirectAxisNumber(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectAxisNumber(kind, handler, param);}
|
|
|
void getIndirectAxisNumber(DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectAxisNumber(handler, param);}
|
|
|
void getIndirectRegisterIdx(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterIdx(kind, handler, param);}
|
|
|
void getIndirectRegisterIdx(DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterIdx(handler, param);}
|
|
|
void getIndirectRegisterSidx(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterSidx(kind, handler, param);}
|
|
|
void getIndirectRegisterSidx(DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterSidx(handler, param);}
|
|
|
void getConcatenatedMvt(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getConcatenatedMvt(kind, handler, param);}
|
|
|
void getConcatenatedMvt(DsaIntHandler handler, void *param = NULL) {DsaBase::getConcatenatedMvt(handler, param);}
|
|
|
void getProfileType(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getProfileType(sidx, kind, handler, param);}
|
|
|
void getProfileType(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getProfileType(sidx, handler, param);}
|
|
|
void getMvtLktNumber(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMvtLktNumber(sidx, kind, handler, param);}
|
|
|
void getMvtLktNumber(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMvtLktNumber(sidx, handler, param);}
|
|
|
void getMvtLktTime(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMvtLktTime(sidx, kind, handler, param);}
|
|
|
void getMvtLktTime(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMvtLktTime(sidx, handler, param);}
|
|
|
void getCameValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCameValue(kind, handler, param);}
|
|
|
void getCameValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCameValue(handler, param);}
|
|
|
void getBrakeDeceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getBrakeDeceleration(kind, handler, param);}
|
|
|
void getBrakeDeceleration(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getBrakeDeceleration(handler, param);}
|
|
|
void getTargetPosition(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTargetPosition(sidx, kind, handler, param);}
|
|
|
void getTargetPosition(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTargetPosition(sidx, handler, param);}
|
|
|
void getProfileVelocity(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileVelocity(sidx, kind, handler, param);}
|
|
|
void getProfileVelocity(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileVelocity(sidx, handler, param);}
|
|
|
void getProfileAcceleration(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileAcceleration(sidx, kind, handler, param);}
|
|
|
void getProfileAcceleration(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileAcceleration(sidx, handler, param);}
|
|
|
void getJerkTime(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getJerkTime(sidx, kind, handler, param);}
|
|
|
void getJerkTime(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getJerkTime(sidx, handler, param);}
|
|
|
void getProfileDeceleration(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileDeceleration(sidx, kind, handler, param);}
|
|
|
void getProfileDeceleration(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileDeceleration(sidx, handler, param);}
|
|
|
void getEndVelocity(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEndVelocity(sidx, kind, handler, param);}
|
|
|
void getEndVelocity(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEndVelocity(sidx, handler, param);}
|
|
|
void getCtrlSourceType(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceType(kind, handler, param);}
|
|
|
void getCtrlSourceType(DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceType(handler, param);}
|
|
|
void getCtrlSourceIndex(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceIndex(kind, handler, param);}
|
|
|
void getCtrlSourceIndex(DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceIndex(handler, param);}
|
|
|
void getCtrlShiftFactor(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlShiftFactor(kind, handler, param);}
|
|
|
void getCtrlShiftFactor(DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlShiftFactor(handler, param);}
|
|
|
void getCtrlOffset(int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getCtrlOffset(kind, handler, param);}
|
|
|
void getCtrlOffset(DsaLongHandler handler, void *param = NULL) {DsaBase::getCtrlOffset(handler, param);}
|
|
|
void getCtrlGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCtrlGain(kind, handler, param);}
|
|
|
void getCtrlGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCtrlGain(handler, param);}
|
|
|
void getMotorKTFactor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMotorKTFactor(kind, handler, param);}
|
|
|
void getMotorKTFactor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMotorKTFactor(handler, param);}
|
|
|
void getPositionCtrlError(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionCtrlError(kind, handler, param);}
|
|
|
void getPositionCtrlError(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionCtrlError(handler, param);}
|
|
|
void getPositionMaxError(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionMaxError(kind, handler, param);}
|
|
|
void getPositionMaxError(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionMaxError(handler, param);}
|
|
|
void getPositionDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionDemandValue(kind, handler, param);}
|
|
|
void getPositionDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionDemandValue(handler, param);}
|
|
|
void getPositionActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionActualValue(kind, handler, param);}
|
|
|
void getPositionActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionActualValue(handler, param);}
|
|
|
void getVelocityDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityDemandValue(kind, handler, param);}
|
|
|
void getVelocityDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityDemandValue(handler, param);}
|
|
|
void getVelocityActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityActualValue(kind, handler, param);}
|
|
|
void getVelocityActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityActualValue(handler, param);}
|
|
|
void getAccDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccDemandValue(kind, handler, param);}
|
|
|
void getAccDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccDemandValue(handler, param);}
|
|
|
void getAccActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccActualValue(kind, handler, param);}
|
|
|
void getAccActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccActualValue(handler, param);}
|
|
|
void getRefDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRefDemandValue(kind, handler, param);}
|
|
|
void getRefDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRefDemandValue(handler, param);}
|
|
|
void getDriveControlMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveControlMask(kind, handler, param);}
|
|
|
void getDriveControlMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveControlMask(handler, param);}
|
|
|
void getCLCurrentPhase1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase1(kind, handler, param);}
|
|
|
void getCLCurrentPhase1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase1(handler, param);}
|
|
|
void getCLCurrentPhase2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase2(kind, handler, param);}
|
|
|
void getCLCurrentPhase2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase2(handler, param);}
|
|
|
void getCLCurrentPhase3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase3(kind, handler, param);}
|
|
|
void getCLCurrentPhase3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase3(handler, param);}
|
|
|
void getCLLktPhase1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase1(kind, handler, param);}
|
|
|
void getCLLktPhase1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase1(handler, param);}
|
|
|
void getCLLktPhase2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase2(kind, handler, param);}
|
|
|
void getCLLktPhase2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase2(handler, param);}
|
|
|
void getCLLktPhase3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase3(kind, handler, param);}
|
|
|
void getCLLktPhase3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase3(handler, param);}
|
|
|
void getCLDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLDemandValue(kind, handler, param);}
|
|
|
void getCLDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLDemandValue(handler, param);}
|
|
|
void getCLActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLActualValue(kind, handler, param);}
|
|
|
void getCLActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLActualValue(handler, param);}
|
|
|
void getEncoderSineSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderSineSignal(kind, handler, param);}
|
|
|
void getEncoderSineSignal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderSineSignal(handler, param);}
|
|
|
void getEncoderCosineSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderCosineSignal(kind, handler, param);}
|
|
|
void getEncoderCosineSignal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderCosineSignal(handler, param);}
|
|
|
void getEncoderIndexSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexSignal(kind, handler, param);}
|
|
|
void getEncoderIndexSignal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexSignal(handler, param);}
|
|
|
void getEncoderHall1Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall1Signal(kind, handler, param);}
|
|
|
void getEncoderHall1Signal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall1Signal(handler, param);}
|
|
|
void getEncoderHall2Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall2Signal(kind, handler, param);}
|
|
|
void getEncoderHall2Signal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall2Signal(handler, param);}
|
|
|
void getEncoderHall3Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall3Signal(kind, handler, param);}
|
|
|
void getEncoderHall3Signal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall3Signal(handler, param);}
|
|
|
void getEncoderHallDigSignal(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getEncoderHallDigSignal(kind, handler, param);}
|
|
|
void getEncoderHallDigSignal(DsaDWordHandler handler, void *param = NULL) {DsaBase::getEncoderHallDigSignal(handler, param);}
|
|
|
void getDigitalInput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalInput(kind, handler, param);}
|
|
|
void getDigitalInput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalInput(handler, param);}
|
|
|
void getAnalogInput(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogInput(kind, handler, param);}
|
|
|
void getAnalogInput(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogInput(handler, param);}
|
|
|
void getXDigitalInput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalInput(kind, handler, param);}
|
|
|
void getXDigitalInput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalInput(handler, param);}
|
|
|
void getXAnalogInput1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput1(kind, handler, param);}
|
|
|
void getXAnalogInput1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput1(handler, param);}
|
|
|
void getXAnalogInput2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput2(kind, handler, param);}
|
|
|
void getXAnalogInput2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput2(handler, param);}
|
|
|
void getXAnalogInput3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput3(kind, handler, param);}
|
|
|
void getXAnalogInput3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput3(handler, param);}
|
|
|
void getXAnalogInput4(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput4(kind, handler, param);}
|
|
|
void getXAnalogInput4(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput4(handler, param);}
|
|
|
void getDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus1(kind, handler, param);}
|
|
|
void getDriveStatus1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus1(handler, param);}
|
|
|
void getDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus2(kind, handler, param);}
|
|
|
void getDriveStatus2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus2(handler, param);}
|
|
|
void getCLI2tValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tValue(kind, handler, param);}
|
|
|
void getCLI2tValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tValue(handler, param);}
|
|
|
void getAxisNumber(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getAxisNumber(kind, handler, param);}
|
|
|
void getAxisNumber(DsaIntHandler handler, void *param = NULL) {DsaBase::getAxisNumber(handler, param);}
|
|
|
void getDaisyChainNumber(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getDaisyChainNumber(kind, handler, param);}
|
|
|
void getDaisyChainNumber(DsaIntHandler handler, void *param = NULL) {DsaBase::getDaisyChainNumber(handler, param);}
|
|
|
void getDriveTemperature(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getDriveTemperature(kind, handler, param);}
|
|
|
void getDriveTemperature(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getDriveTemperature(handler, param);}
|
|
|
void getDriveMaskValue(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveMaskValue(kind, handler, param);}
|
|
|
void getDriveMaskValue(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveMaskValue(handler, param);}
|
|
|
void getDriveDisplay(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveDisplay(sidx, kind, handler, param);}
|
|
|
void getDriveDisplay(int sidx, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveDisplay(sidx, handler, param);}
|
|
|
void getDriveSequenceLine(int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getDriveSequenceLine(kind, handler, param);}
|
|
|
void getDriveSequenceLine(DsaLongHandler handler, void *param = NULL) {DsaBase::getDriveSequenceLine(handler, param);}
|
|
|
void getDriveFuseStatus(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseStatus(kind, handler, param);}
|
|
|
void getDriveFuseStatus(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseStatus(handler, param);}
|
|
|
void getIrqDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus1(kind, handler, param);}
|
|
|
void getIrqDriveStatus1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus1(handler, param);}
|
|
|
void getIrqDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus2(kind, handler, param);}
|
|
|
void getIrqDriveStatus2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus2(handler, param);}
|
|
|
void getAckDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus1(kind, handler, param);}
|
|
|
void getAckDriveStatus1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus1(handler, param);}
|
|
|
void getAckDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus2(kind, handler, param);}
|
|
|
void getAckDriveStatus2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus2(handler, param);}
|
|
|
void getIrqPendingAxisMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqPendingAxisMask(kind, handler, param);}
|
|
|
void getIrqPendingAxisMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqPendingAxisMask(handler, param);}
|
|
|
void getCanFeedback1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback1(kind, handler, param);}
|
|
|
void getCanFeedback1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback1(handler, param);}
|
|
|
void getCanFeedback2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback2(kind, handler, param);}
|
|
|
void getCanFeedback2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback2(handler, param);}
|
|
|
void getNbAvailableSlot(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getNbAvailableSlot(kind, handler, param);}
|
|
|
void getNbAvailableSlot(DsaIntHandler handler, void *param = NULL) {DsaBase::getNbAvailableSlot(handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDriveGroup class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDriveGroup: public DsaBase {
|
|
|
/* constructors */
|
|
|
private:
|
|
|
void _Group(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_drive_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
protected:
|
|
|
DsaDriveGroup(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaDriveGroup(DsaDriveGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDriveGroup(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDriveGroup(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_drive_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
DsaDriveGroup(int max, DsaDriveBase *list[]) {
|
|
|
ERRCHK(dsa_create_drive_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, list[i]->dsa));
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2) {
|
|
|
_Group(2, &d1, &d2);
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3) {
|
|
|
_Group(3, &d1, &d2, &d3);
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4) {
|
|
|
_Group(4, &d1, &d2, &d3, &d4);
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5) {
|
|
|
_Group(5, &d1, &d2, &d3, &d4, &d5);
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6) {
|
|
|
_Group(6, &d1, &d2, &d3, &d4, &d5, &d6);
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6, DsaDriveBase d7) {
|
|
|
_Group(7, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
|
|
}
|
|
|
DsaDriveGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6, DsaDriveBase d7, DsaDriveBase d8) {
|
|
|
_Group(8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8);
|
|
|
}
|
|
|
/* operators */
|
|
|
public:
|
|
|
DsaDriveGroup operator = (DsaDriveGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDriveGroup operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
public:
|
|
|
DsaDriveBase getGroupItem(int pos) {return DsaBase::getGroupItem(pos);}
|
|
|
/* functions */
|
|
|
void powerOn(long timeout = DEF_TIMEOUT) {DsaBase::powerOn(timeout);}
|
|
|
void powerOff(long timeout = DEF_TIMEOUT) {DsaBase::powerOff(timeout);}
|
|
|
void newSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::newSetpoint(sidx, flags, timeout);}
|
|
|
void changeSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::changeSetpoint(sidx, flags, timeout);}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void homingStart(long timeout = DEF_TIMEOUT) {DsaBase::homingStart(timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, long timeout = DEF_TIMEOUT) {DsaBase::startProfiledMovement(pos, speed, acc, timeout);}
|
|
|
void startRelativeProfiledMovement(double relativePos, long timeout = DEF_TIMEOUT) {DsaBase::startRelativeProfiledMovement(relativePos, timeout);}
|
|
|
void stageMappingDownload(const char *fileName) {DsaBase::stageMappingDownload(fileName);}
|
|
|
void stageMappingUpload(const char *fileName) {DsaBase::stageMappingUpload(fileName);}
|
|
|
void stageMappingActivate() {DsaBase::stageMappingActivate();}
|
|
|
void stageMappingDeactivate() {DsaBase::stageMappingDeactivate();}
|
|
|
bool stageMappingIsActivated() {return DsaBase::stageMappingIsActivated();}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void powerOn(DsaHandler handler, void *param = NULL) {DsaBase::powerOn(handler, param);}
|
|
|
void powerOff(DsaHandler handler, void *param = NULL) {DsaBase::powerOff(handler, param);}
|
|
|
void newSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::newSetpoint(sidx, flags, handler, param);}
|
|
|
void changeSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::changeSetpoint(sidx, flags, handler, param);}
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void homingStart(DsaHandler handler, void *param = NULL) {DsaBase::homingStart(handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, DsaHandler handler, void *param = NULL) {DsaBase::startProfiledMovement(pos, speed, acc, handler, param);}
|
|
|
void startRelativeProfiledMovement(double relativePos, DsaHandler handler, void *param = NULL) {DsaBase::startRelativeProfiledMovement(relativePos, handler, param);}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void getRtmMon(DsaRTM *rtm) {DsaBase::getRtmMon(rtm);}
|
|
|
void initRtmFct() {DsaBase::initRtmFct();}
|
|
|
void startRtm(DsaTrajectoryHandler fct) {DsaBase::startRtm(fct);}
|
|
|
void stopRtm() {DsaBase::stopRtm();}
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
int getGroupSize() {return DsaBase::getGroupSize();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void stepMotion(double pos, long timeout = DEF_TIMEOUT) {DsaBase::stepMotion(pos, timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void canCommand1(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand1(val1, val2, timeout);}
|
|
|
void canCommand2(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand2(val1, val2, timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void stepMotion(double pos, DsaHandler handler, void *param = NULL) {DsaBase::stepMotion(pos, handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void canCommand1(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand1(val1, val2, handler, param);}
|
|
|
void canCommand2(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand2(val1, val2, handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
|
|
|
/* register setters */
|
|
|
void setPLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLProportionalGain(gain, timeout);}
|
|
|
void setPLSpeedFeedbackGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedbackGain(gain, timeout);}
|
|
|
void setPLForceFeedbackGain1(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain1(gain, timeout);}
|
|
|
void setPLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorGain(gain, timeout);}
|
|
|
void setPLAntiWindupGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLAntiWindupGain(gain, timeout);}
|
|
|
void setPLIntegratorLimitation(double limit, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorLimitation(limit, timeout);}
|
|
|
void setPLIntegratorMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorMode(mode, timeout);}
|
|
|
void setPLSpeedFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFilter(tim, timeout);}
|
|
|
void setPLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLOutputFilter(tim, timeout);}
|
|
|
void setCLInputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLInputFilter(tim, timeout);}
|
|
|
void setTtlSpecialFilter(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setTtlSpecialFilter(factor, timeout);}
|
|
|
void setPLForceFeedbackGain2(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain2(factor, timeout);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedfwdGain(factor, timeout);}
|
|
|
void setPLAccFeedforwardGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLAccFeedforwardGain(factor, timeout);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceFactor(factor, timeout);}
|
|
|
void setAprInputFilter(double time, long timeout = DEF_TIMEOUT) {DsaBase::setAprInputFilter(time, timeout);}
|
|
|
void setCLPhaseAdvanceShift(double shift, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceShift(shift, timeout);}
|
|
|
void setMinPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxProfileVelocity(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setMaxProfileVelocity(vel, timeout);}
|
|
|
void setMaxAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setMaxAcceleration(acc, timeout);}
|
|
|
void startMovement(double *targets, long timeout = DEF_TIMEOUT) {DsaBase::startMovement(targets, timeout);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setFollowingErrorWindow(pos, timeout);}
|
|
|
void setVelocityErrorLimit(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setVelocityErrorLimit(vel, timeout);}
|
|
|
void setSwitchLimitMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setSwitchLimitMode(mode, timeout);}
|
|
|
void setEnableInputMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setEnableInputMode(mode, timeout);}
|
|
|
void setMinSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinSoftPositionLimit(pos, timeout);}
|
|
|
void setMaxSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxSoftPositionLimit(pos, timeout);}
|
|
|
void setProfileLimitMode(dword flags, long timeout = DEF_TIMEOUT) {DsaBase::setProfileLimitMode(flags, timeout);}
|
|
|
void setIOErrorEventMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setIOErrorEventMask(mask, timeout);}
|
|
|
void setPositionWindowTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindowTime(tim, timeout);}
|
|
|
void setPositionWindow(double win, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindow(win, timeout);}
|
|
|
void setHomingMethod(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingMethod(mode, timeout);}
|
|
|
void setHomingZeroSpeed(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setHomingZeroSpeed(vel, timeout);}
|
|
|
void setHomingAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setHomingAcceleration(acc, timeout);}
|
|
|
void setHomingFollowingLimit(double win, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFollowingLimit(win, timeout);}
|
|
|
void setHomingCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setHomingCurrentLimit(cur, timeout);}
|
|
|
void setHomeOffset(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomeOffset(pos, timeout);}
|
|
|
void setHomingFixedMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFixedMvt(pos, timeout);}
|
|
|
void setHomingSwitchMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingSwitchMvt(pos, timeout);}
|
|
|
void setHomingIndexMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingIndexMvt(pos, timeout);}
|
|
|
void setHomingFineTuningMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningMode(mode, timeout);}
|
|
|
void setHomingFineTuningValue(double phase, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningValue(phase, timeout);}
|
|
|
void setMotorPhaseCorrection(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setMotorPhaseCorrection(mode, timeout);}
|
|
|
void setSoftwareCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setSoftwareCurrentLimit(cur, timeout);}
|
|
|
void setDriveControlMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDriveControlMode(mode, timeout);}
|
|
|
void setDisplayMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDisplayMode(mode, timeout);}
|
|
|
void setEncoderInversion(double invert, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderInversion(invert, timeout);}
|
|
|
void setPdrStepValue(double step, long timeout = DEF_TIMEOUT) {DsaBase::setPdrStepValue(step, timeout);}
|
|
|
void setEncoderPhase1Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Offset(offset, timeout);}
|
|
|
void setEncoderPhase2Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Offset(offset, timeout);}
|
|
|
void setEncoderPhase1Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Factor(factor, timeout);}
|
|
|
void setEncoderPhase2Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Factor(factor, timeout);}
|
|
|
void setEncoderPhase3Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Offset(offset, timeout);}
|
|
|
void setEncoderIndexDistance(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderIndexDistance(pos, timeout);}
|
|
|
void setEncoderPhase3Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Factor(factor, timeout);}
|
|
|
void setCLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLProportionalGain(gain, timeout);}
|
|
|
void setCLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLIntegratorGain(gain, timeout);}
|
|
|
void setCLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLOutputFilter(tim, timeout);}
|
|
|
void setCLCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tTimeLimit(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tTimeLimit(tim, timeout);}
|
|
|
void setCLRegenMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setCLRegenMode(mode, timeout);}
|
|
|
void setInitMode(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setInitMode(typ, timeout);}
|
|
|
void setInitPulseLevel(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitPulseLevel(cur, timeout);}
|
|
|
void setInitMaxCurrent(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitMaxCurrent(cur, timeout);}
|
|
|
void setInitFinalPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitFinalPhase(cal, timeout);}
|
|
|
void setInitTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setInitTime(tim, timeout);}
|
|
|
void setInitCurrentRate(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitCurrentRate(cur, timeout);}
|
|
|
void setInitPhaseRate(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitPhaseRate(cal, timeout);}
|
|
|
void setInitInitialPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitInitialPhase(cal, timeout);}
|
|
|
void setDriveFuseChecking(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setDriveFuseChecking(mask, timeout);}
|
|
|
void setMotorTempChecking(dword val, long timeout = DEF_TIMEOUT) {DsaBase::setMotorTempChecking(val, timeout);}
|
|
|
void setMonSourceType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceType(sidx, typ, timeout);}
|
|
|
void setMonSourceIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceIndex(sidx, index, timeout);}
|
|
|
void setMonDestIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonDestIndex(sidx, index, timeout);}
|
|
|
void setMonOffset(int sidx, long offset, long timeout = DEF_TIMEOUT) {DsaBase::setMonOffset(sidx, offset, timeout);}
|
|
|
void setMonGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setMonGain(sidx, gain, timeout);}
|
|
|
void setXAnalogOffset(int sidx, double offset, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOffset(sidx, offset, timeout);}
|
|
|
void setXAnalogGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogGain(sidx, gain, timeout);}
|
|
|
void setSyncroInputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputMask(mask, timeout);}
|
|
|
void setSyncroInputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputValue(mask, timeout);}
|
|
|
void setSyncroOutputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputMask(mask, timeout);}
|
|
|
void setSyncroOutputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputValue(mask, timeout);}
|
|
|
void setSyncroStartTimeout(int tim, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroStartTimeout(tim, timeout);}
|
|
|
void setDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setDigitalOutput(out, timeout);}
|
|
|
void setXDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setXDigitalOutput(out, timeout);}
|
|
|
void setXAnalogOutput1(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput1(out, timeout);}
|
|
|
void setXAnalogOutput2(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput2(out, timeout);}
|
|
|
void setXAnalogOutput3(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput3(out, timeout);}
|
|
|
void setXAnalogOutput4(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput4(out, timeout);}
|
|
|
void setAnalogOutput(double out, long timeout = DEF_TIMEOUT) {DsaBase::setAnalogOutput(out, timeout);}
|
|
|
void setInterruptMask1(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask1(sidx, mask, timeout);}
|
|
|
void setInterruptMask2(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask2(sidx, mask, timeout);}
|
|
|
void setTriggerIrqMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIrqMask(mask, timeout);}
|
|
|
void setTriggerIOMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIOMask(mask, timeout);}
|
|
|
void setTriggerMapOffset(int offset, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapOffset(offset, timeout);}
|
|
|
void setTriggerMapSize(int size, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapSize(size, timeout);}
|
|
|
void setRealtimeEnabledGlobal(int enable, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledGlobal(enable, timeout);}
|
|
|
void setRealtimeValidMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeValidMask(mask, timeout);}
|
|
|
void setRealtimeEnabledMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledMask(mask, timeout);}
|
|
|
void setRealtimePendingMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimePendingMask(mask, timeout);}
|
|
|
void setEblBaudrate(long baud, long timeout = DEF_TIMEOUT) {DsaBase::setEblBaudrate(baud, timeout);}
|
|
|
void setIndirectAxisNumber(int axis, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectAxisNumber(axis, timeout);}
|
|
|
void setIndirectRegisterIdx(int idx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterIdx(idx, timeout);}
|
|
|
void setIndirectRegisterSidx(int sidx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterSidx(sidx, timeout);}
|
|
|
void setConcatenatedMvt(int concat, long timeout = DEF_TIMEOUT) {DsaBase::setConcatenatedMvt(concat, timeout);}
|
|
|
void setProfileType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setProfileType(sidx, typ, timeout);}
|
|
|
void setMvtLktNumber(int sidx, int number, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktNumber(sidx, number, timeout);}
|
|
|
void setMvtLktTime(int sidx, double time, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktTime(sidx, time, timeout);}
|
|
|
void setCameValue(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCameValue(factor, timeout);}
|
|
|
void setBrakeDeceleration(double dec, long timeout = DEF_TIMEOUT) {DsaBase::setBrakeDeceleration(dec, timeout);}
|
|
|
void setTargetPosition(int sidx, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTargetPosition(sidx, pos, timeout);}
|
|
|
void setProfileVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setProfileVelocity(sidx, vel, timeout);}
|
|
|
void setProfileAcceleration(int sidx, double acc, long timeout = DEF_TIMEOUT) {DsaBase::setProfileAcceleration(sidx, acc, timeout);}
|
|
|
void setJerkTime(int sidx, double tim, long timeout = DEF_TIMEOUT) {DsaBase::setJerkTime(sidx, tim, timeout);}
|
|
|
void setProfileDeceleration(int sidx, double dec, long timeout = DEF_TIMEOUT) {DsaBase::setProfileDeceleration(sidx, dec, timeout);}
|
|
|
void setEndVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setEndVelocity(sidx, vel, timeout);}
|
|
|
void setCtrlSourceType(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceType(typ, timeout);}
|
|
|
void setCtrlSourceIndex(int index, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceIndex(index, timeout);}
|
|
|
void setCtrlShiftFactor(int shift, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlShiftFactor(shift, timeout);}
|
|
|
void setCtrlOffset(long offset, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlOffset(offset, timeout);}
|
|
|
void setCtrlGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlGain(gain, timeout);}
|
|
|
void setMotorKTFactor(double kt, long timeout = DEF_TIMEOUT) {DsaBase::setMotorKTFactor(kt, timeout);}
|
|
|
|
|
|
void setPLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLProportionalGain(gain, handler, param);}
|
|
|
void setPLSpeedFeedbackGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedbackGain(gain, handler, param);}
|
|
|
void setPLForceFeedbackGain1(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain1(gain, handler, param);}
|
|
|
void setPLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorGain(gain, handler, param);}
|
|
|
void setPLAntiWindupGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLAntiWindupGain(gain, handler, param);}
|
|
|
void setPLIntegratorLimitation(double limit, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorLimitation(limit, handler, param);}
|
|
|
void setPLIntegratorMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorMode(mode, handler, param);}
|
|
|
void setPLSpeedFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFilter(tim, handler, param);}
|
|
|
void setPLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLOutputFilter(tim, handler, param);}
|
|
|
void setCLInputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLInputFilter(tim, handler, param);}
|
|
|
void setTtlSpecialFilter(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setTtlSpecialFilter(factor, handler, param);}
|
|
|
void setPLForceFeedbackGain2(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain2(factor, handler, param);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedfwdGain(factor, handler, param);}
|
|
|
void setPLAccFeedforwardGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLAccFeedforwardGain(factor, handler, param);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceFactor(factor, handler, param);}
|
|
|
void setAprInputFilter(double time, DsaHandler handler, void *param = NULL) {DsaBase::setAprInputFilter(time, handler, param);}
|
|
|
void setCLPhaseAdvanceShift(double shift, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceShift(shift, handler, param);}
|
|
|
void setMinPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxProfileVelocity(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setMaxProfileVelocity(vel, handler, param);}
|
|
|
void setMaxAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setMaxAcceleration(acc, handler, param);}
|
|
|
void startMovement(double *targets, DsaHandler handler, void *param = NULL) {DsaBase::startMovement(targets, handler, param);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setFollowingErrorWindow(pos, handler, param);}
|
|
|
void setVelocityErrorLimit(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setVelocityErrorLimit(vel, handler, param);}
|
|
|
void setSwitchLimitMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setSwitchLimitMode(mode, handler, param);}
|
|
|
void setEnableInputMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setEnableInputMode(mode, handler, param);}
|
|
|
void setMinSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinSoftPositionLimit(pos, handler, param);}
|
|
|
void setMaxSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxSoftPositionLimit(pos, handler, param);}
|
|
|
void setProfileLimitMode(dword flags, DsaHandler handler, void *param = NULL) {DsaBase::setProfileLimitMode(flags, handler, param);}
|
|
|
void setIOErrorEventMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setIOErrorEventMask(mask, handler, param);}
|
|
|
void setPositionWindowTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindowTime(tim, handler, param);}
|
|
|
void setPositionWindow(double win, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindow(win, handler, param);}
|
|
|
void setHomingMethod(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingMethod(mode, handler, param);}
|
|
|
void setHomingZeroSpeed(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setHomingZeroSpeed(vel, handler, param);}
|
|
|
void setHomingAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setHomingAcceleration(acc, handler, param);}
|
|
|
void setHomingFollowingLimit(double win, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFollowingLimit(win, handler, param);}
|
|
|
void setHomingCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setHomingCurrentLimit(cur, handler, param);}
|
|
|
void setHomeOffset(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomeOffset(pos, handler, param);}
|
|
|
void setHomingFixedMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFixedMvt(pos, handler, param);}
|
|
|
void setHomingSwitchMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingSwitchMvt(pos, handler, param);}
|
|
|
void setHomingIndexMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingIndexMvt(pos, handler, param);}
|
|
|
void setHomingFineTuningMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningMode(mode, handler, param);}
|
|
|
void setHomingFineTuningValue(double phase, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningValue(phase, handler, param);}
|
|
|
void setMotorPhaseCorrection(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setMotorPhaseCorrection(mode, handler, param);}
|
|
|
void setSoftwareCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setSoftwareCurrentLimit(cur, handler, param);}
|
|
|
void setDriveControlMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDriveControlMode(mode, handler, param);}
|
|
|
void setDisplayMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDisplayMode(mode, handler, param);}
|
|
|
void setEncoderInversion(double invert, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderInversion(invert, handler, param);}
|
|
|
void setPdrStepValue(double step, DsaHandler handler, void *param = NULL) {DsaBase::setPdrStepValue(step, handler, param);}
|
|
|
void setEncoderPhase1Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Offset(offset, handler, param);}
|
|
|
void setEncoderPhase2Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Offset(offset, handler, param);}
|
|
|
void setEncoderPhase1Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Factor(factor, handler, param);}
|
|
|
void setEncoderPhase2Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Factor(factor, handler, param);}
|
|
|
void setEncoderPhase3Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Offset(offset, handler, param);}
|
|
|
void setEncoderIndexDistance(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderIndexDistance(pos, handler, param);}
|
|
|
void setEncoderPhase3Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Factor(factor, handler, param);}
|
|
|
void setCLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLProportionalGain(gain, handler, param);}
|
|
|
void setCLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLIntegratorGain(gain, handler, param);}
|
|
|
void setCLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLOutputFilter(tim, handler, param);}
|
|
|
void setCLCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tTimeLimit(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tTimeLimit(tim, handler, param);}
|
|
|
void setCLRegenMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setCLRegenMode(mode, handler, param);}
|
|
|
void setInitMode(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setInitMode(typ, handler, param);}
|
|
|
void setInitPulseLevel(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitPulseLevel(cur, handler, param);}
|
|
|
void setInitMaxCurrent(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitMaxCurrent(cur, handler, param);}
|
|
|
void setInitFinalPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitFinalPhase(cal, handler, param);}
|
|
|
void setInitTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setInitTime(tim, handler, param);}
|
|
|
void setInitCurrentRate(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitCurrentRate(cur, handler, param);}
|
|
|
void setInitPhaseRate(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitPhaseRate(cal, handler, param);}
|
|
|
void setInitInitialPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitInitialPhase(cal, handler, param);}
|
|
|
void setDriveFuseChecking(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setDriveFuseChecking(mask, handler, param);}
|
|
|
void setMotorTempChecking(dword val, DsaHandler handler, void *param = NULL) {DsaBase::setMotorTempChecking(val, handler, param);}
|
|
|
void setMonSourceType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceType(sidx, typ, handler, param);}
|
|
|
void setMonSourceIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceIndex(sidx, index, handler, param);}
|
|
|
void setMonDestIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonDestIndex(sidx, index, handler, param);}
|
|
|
void setMonOffset(int sidx, long offset, DsaHandler handler, void *param = NULL) {DsaBase::setMonOffset(sidx, offset, handler, param);}
|
|
|
void setMonGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setMonGain(sidx, gain, handler, param);}
|
|
|
void setXAnalogOffset(int sidx, double offset, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOffset(sidx, offset, handler, param);}
|
|
|
void setXAnalogGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogGain(sidx, gain, handler, param);}
|
|
|
void setSyncroInputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputMask(mask, handler, param);}
|
|
|
void setSyncroInputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputValue(mask, handler, param);}
|
|
|
void setSyncroOutputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputMask(mask, handler, param);}
|
|
|
void setSyncroOutputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputValue(mask, handler, param);}
|
|
|
void setSyncroStartTimeout(int tim, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroStartTimeout(tim, handler, param);}
|
|
|
void setDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setDigitalOutput(out, handler, param);}
|
|
|
void setXDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setXDigitalOutput(out, handler, param);}
|
|
|
void setXAnalogOutput1(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput1(out, handler, param);}
|
|
|
void setXAnalogOutput2(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput2(out, handler, param);}
|
|
|
void setXAnalogOutput3(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput3(out, handler, param);}
|
|
|
void setXAnalogOutput4(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput4(out, handler, param);}
|
|
|
void setAnalogOutput(double out, DsaHandler handler, void *param = NULL) {DsaBase::setAnalogOutput(out, handler, param);}
|
|
|
void setInterruptMask1(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask1(sidx, mask, handler, param);}
|
|
|
void setInterruptMask2(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask2(sidx, mask, handler, param);}
|
|
|
void setTriggerIrqMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIrqMask(mask, handler, param);}
|
|
|
void setTriggerIOMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIOMask(mask, handler, param);}
|
|
|
void setTriggerMapOffset(int offset, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapOffset(offset, handler, param);}
|
|
|
void setTriggerMapSize(int size, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapSize(size, handler, param);}
|
|
|
void setRealtimeEnabledGlobal(int enable, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledGlobal(enable, handler, param);}
|
|
|
void setRealtimeValidMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeValidMask(mask, handler, param);}
|
|
|
void setRealtimeEnabledMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledMask(mask, handler, param);}
|
|
|
void setRealtimePendingMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimePendingMask(mask, handler, param);}
|
|
|
void setEblBaudrate(long baud, DsaHandler handler, void *param = NULL) {DsaBase::setEblBaudrate(baud, handler, param);}
|
|
|
void setIndirectAxisNumber(int axis, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectAxisNumber(axis, handler, param);}
|
|
|
void setIndirectRegisterIdx(int idx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterIdx(idx, handler, param);}
|
|
|
void setIndirectRegisterSidx(int sidx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterSidx(sidx, handler, param);}
|
|
|
void setConcatenatedMvt(int concat, DsaHandler handler, void *param = NULL) {DsaBase::setConcatenatedMvt(concat, handler, param);}
|
|
|
void setProfileType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setProfileType(sidx, typ, handler, param);}
|
|
|
void setMvtLktNumber(int sidx, int number, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktNumber(sidx, number, handler, param);}
|
|
|
void setMvtLktTime(int sidx, double time, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktTime(sidx, time, handler, param);}
|
|
|
void setCameValue(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCameValue(factor, handler, param);}
|
|
|
void setBrakeDeceleration(double dec, DsaHandler handler, void *param = NULL) {DsaBase::setBrakeDeceleration(dec, handler, param);}
|
|
|
void setTargetPosition(int sidx, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTargetPosition(sidx, pos, handler, param);}
|
|
|
void setProfileVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setProfileVelocity(sidx, vel, handler, param);}
|
|
|
void setProfileAcceleration(int sidx, double acc, DsaHandler handler, void *param = NULL) {DsaBase::setProfileAcceleration(sidx, acc, handler, param);}
|
|
|
void setJerkTime(int sidx, double tim, DsaHandler handler, void *param = NULL) {DsaBase::setJerkTime(sidx, tim, handler, param);}
|
|
|
void setProfileDeceleration(int sidx, double dec, DsaHandler handler, void *param = NULL) {DsaBase::setProfileDeceleration(sidx, dec, handler, param);}
|
|
|
void setEndVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setEndVelocity(sidx, vel, handler, param);}
|
|
|
void setCtrlSourceType(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceType(typ, handler, param);}
|
|
|
void setCtrlSourceIndex(int index, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceIndex(index, handler, param);}
|
|
|
void setCtrlShiftFactor(int shift, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlShiftFactor(shift, handler, param);}
|
|
|
void setCtrlOffset(long offset, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlOffset(offset, handler, param);}
|
|
|
void setCtrlGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlGain(gain, handler, param);}
|
|
|
void setMotorKTFactor(double kt, DsaHandler handler, void *param = NULL) {DsaBase::setMotorKTFactor(kt, handler, param);}
|
|
|
};
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaGantry class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaGantry: public DsaBase {
|
|
|
/* constructors */
|
|
|
protected:
|
|
|
DsaGantry(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaGantry(DsaGantry &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaGantry(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaGantry(DsaDriveBase d1, DsaDriveBase d2) {
|
|
|
ERRCHK(dsa_create_gantry(&dsa));
|
|
|
ERRCHK(dsa_set_group_item(dsa, 0, d1.dsa));
|
|
|
ERRCHK(dsa_set_group_item(dsa, 1, d2.dsa));
|
|
|
}
|
|
|
/* operators */
|
|
|
public:
|
|
|
DsaGantry operator = (DsaGantry &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaGantry operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_drive_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
public:
|
|
|
DsaGantry getGroupItem(int pos) {return DsaBase::getGroupItem(pos);}
|
|
|
void powerOn(long timeout = DEF_TIMEOUT) {DsaBase::powerOn(timeout);}
|
|
|
void powerOff(long timeout = DEF_TIMEOUT) {DsaBase::powerOff(timeout);}
|
|
|
void newSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::newSetpoint(sidx, flags, timeout);}
|
|
|
void changeSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::changeSetpoint(sidx, flags, timeout);}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void homingStart(long timeout = DEF_TIMEOUT) {DsaBase::homingStart(timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, long timeout = DEF_TIMEOUT) {DsaBase::startProfiledMovement(pos, speed, acc, timeout);}
|
|
|
void startRelativeProfiledMovement(double relativePos, long timeout = DEF_TIMEOUT) {DsaBase::startRelativeProfiledMovement(relativePos, timeout);}
|
|
|
void stageMappingDownload(const char *fileName) {DsaBase::stageMappingDownload(fileName);}
|
|
|
void stageMappingUpload(const char *fileName) {DsaBase::stageMappingUpload(fileName);}
|
|
|
void stageMappingActivate() {DsaBase::stageMappingActivate();}
|
|
|
void stageMappingDeactivate() {DsaBase::stageMappingDeactivate();}
|
|
|
bool stageMappingIsActivated() {return DsaBase::stageMappingIsActivated();}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void gantryWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::gantryWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void gantryWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::gantryWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void powerOn(DsaHandler handler, void *param = NULL) {DsaBase::powerOn(handler, param);}
|
|
|
void powerOff(DsaHandler handler, void *param = NULL) {DsaBase::powerOff(handler, param);}
|
|
|
void newSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::newSetpoint(sidx, flags, handler, param);}
|
|
|
void changeSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::changeSetpoint(sidx, flags, handler, param);}
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void homingStart(DsaHandler handler, void *param = NULL) {DsaBase::homingStart(handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, DsaHandler handler, void *param = NULL) {DsaBase::startProfiledMovement(pos, speed, acc, handler, param);}
|
|
|
void startRelativeProfiledMovement(double relativePos, DsaHandler handler, void *param = NULL) {DsaBase::startRelativeProfiledMovement(relativePos, handler, param);}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void gantryWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::gantryWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void gantryWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::gantryWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void getRtmMon(DsaRTM *rtm) {DsaBase::getRtmMon(rtm);}
|
|
|
void initRtmFct() {DsaBase::initRtmFct();}
|
|
|
void startRtm(DsaTrajectoryHandler fct) {DsaBase::startRtm(fct);}
|
|
|
void stopRtm() {DsaBase::stopRtm();}
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
int getGroupSize() {return DsaBase::getGroupSize();}
|
|
|
int gantryGetErrorCode(int *axis, int kind) {return DsaBase::gantryGetErrorCode(axis, kind);}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void gantryCancelStatusWait() {DsaBase::gantryCancelStatusWait();}
|
|
|
DsaStatus gantryGetAndStatus() {return DsaBase::gantryGetAndStatus();}
|
|
|
DsaStatus gantryGetORStatus() {return DsaBase::gantryGetORStatus();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void stepMotion(double pos, long timeout = DEF_TIMEOUT) {DsaBase::stepMotion(pos, timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void canCommand1(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand1(val1, val2, timeout);}
|
|
|
void canCommand2(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand2(val1, val2, timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void stepMotion(double pos, DsaHandler handler, void *param = NULL) {DsaBase::stepMotion(pos, handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void canCommand1(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand1(val1, val2, handler, param);}
|
|
|
void canCommand2(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand2(val1, val2, handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
|
|
|
/* register setters */
|
|
|
void setPLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLProportionalGain(gain, timeout);}
|
|
|
void setPLSpeedFeedbackGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedbackGain(gain, timeout);}
|
|
|
void setPLForceFeedbackGain1(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain1(gain, timeout);}
|
|
|
void setPLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorGain(gain, timeout);}
|
|
|
void setPLAntiWindupGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLAntiWindupGain(gain, timeout);}
|
|
|
void setPLIntegratorLimitation(double limit, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorLimitation(limit, timeout);}
|
|
|
void setPLIntegratorMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorMode(mode, timeout);}
|
|
|
void setPLSpeedFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFilter(tim, timeout);}
|
|
|
void setPLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLOutputFilter(tim, timeout);}
|
|
|
void setCLInputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLInputFilter(tim, timeout);}
|
|
|
void setTtlSpecialFilter(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setTtlSpecialFilter(factor, timeout);}
|
|
|
void setPLForceFeedbackGain2(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain2(factor, timeout);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedfwdGain(factor, timeout);}
|
|
|
void setPLAccFeedforwardGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLAccFeedforwardGain(factor, timeout);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceFactor(factor, timeout);}
|
|
|
void setAprInputFilter(double time, long timeout = DEF_TIMEOUT) {DsaBase::setAprInputFilter(time, timeout);}
|
|
|
void setCLPhaseAdvanceShift(double shift, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceShift(shift, timeout);}
|
|
|
void setMinPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxProfileVelocity(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setMaxProfileVelocity(vel, timeout);}
|
|
|
void setMaxAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setMaxAcceleration(acc, timeout);}
|
|
|
void startMovement(double *targets, long timeout = DEF_TIMEOUT) {DsaBase::startMovement(targets, timeout);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setFollowingErrorWindow(pos, timeout);}
|
|
|
void setVelocityErrorLimit(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setVelocityErrorLimit(vel, timeout);}
|
|
|
void setSwitchLimitMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setSwitchLimitMode(mode, timeout);}
|
|
|
void setEnableInputMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setEnableInputMode(mode, timeout);}
|
|
|
void setMinSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinSoftPositionLimit(pos, timeout);}
|
|
|
void setMaxSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxSoftPositionLimit(pos, timeout);}
|
|
|
void setProfileLimitMode(dword flags, long timeout = DEF_TIMEOUT) {DsaBase::setProfileLimitMode(flags, timeout);}
|
|
|
void setIOErrorEventMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setIOErrorEventMask(mask, timeout);}
|
|
|
void setPositionWindowTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindowTime(tim, timeout);}
|
|
|
void setPositionWindow(double win, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindow(win, timeout);}
|
|
|
void setHomingMethod(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingMethod(mode, timeout);}
|
|
|
void setHomingZeroSpeed(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setHomingZeroSpeed(vel, timeout);}
|
|
|
void setHomingAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setHomingAcceleration(acc, timeout);}
|
|
|
void setHomingFollowingLimit(double win, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFollowingLimit(win, timeout);}
|
|
|
void setHomingCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setHomingCurrentLimit(cur, timeout);}
|
|
|
void setHomeOffset(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomeOffset(pos, timeout);}
|
|
|
void setHomingFixedMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFixedMvt(pos, timeout);}
|
|
|
void setHomingSwitchMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingSwitchMvt(pos, timeout);}
|
|
|
void setHomingIndexMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingIndexMvt(pos, timeout);}
|
|
|
void setHomingFineTuningMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningMode(mode, timeout);}
|
|
|
void setHomingFineTuningValue(double phase, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningValue(phase, timeout);}
|
|
|
void setMotorPhaseCorrection(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setMotorPhaseCorrection(mode, timeout);}
|
|
|
void setSoftwareCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setSoftwareCurrentLimit(cur, timeout);}
|
|
|
void setDriveControlMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDriveControlMode(mode, timeout);}
|
|
|
void setDisplayMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDisplayMode(mode, timeout);}
|
|
|
void setEncoderInversion(double invert, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderInversion(invert, timeout);}
|
|
|
void setPdrStepValue(double step, long timeout = DEF_TIMEOUT) {DsaBase::setPdrStepValue(step, timeout);}
|
|
|
void setEncoderPhase1Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Offset(offset, timeout);}
|
|
|
void setEncoderPhase2Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Offset(offset, timeout);}
|
|
|
void setEncoderPhase1Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Factor(factor, timeout);}
|
|
|
void setEncoderPhase2Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Factor(factor, timeout);}
|
|
|
void setEncoderPhase3Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Offset(offset, timeout);}
|
|
|
void setEncoderIndexDistance(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderIndexDistance(pos, timeout);}
|
|
|
void setEncoderPhase3Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Factor(factor, timeout);}
|
|
|
void setCLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLProportionalGain(gain, timeout);}
|
|
|
void setCLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLIntegratorGain(gain, timeout);}
|
|
|
void setCLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLOutputFilter(tim, timeout);}
|
|
|
void setCLCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tTimeLimit(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tTimeLimit(tim, timeout);}
|
|
|
void setCLRegenMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setCLRegenMode(mode, timeout);}
|
|
|
void setInitMode(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setInitMode(typ, timeout);}
|
|
|
void setInitPulseLevel(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitPulseLevel(cur, timeout);}
|
|
|
void setInitMaxCurrent(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitMaxCurrent(cur, timeout);}
|
|
|
void setInitFinalPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitFinalPhase(cal, timeout);}
|
|
|
void setInitTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setInitTime(tim, timeout);}
|
|
|
void setInitCurrentRate(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitCurrentRate(cur, timeout);}
|
|
|
void setInitPhaseRate(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitPhaseRate(cal, timeout);}
|
|
|
void setInitInitialPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitInitialPhase(cal, timeout);}
|
|
|
void setDriveFuseChecking(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setDriveFuseChecking(mask, timeout);}
|
|
|
void setMotorTempChecking(dword val, long timeout = DEF_TIMEOUT) {DsaBase::setMotorTempChecking(val, timeout);}
|
|
|
void setMonSourceType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceType(sidx, typ, timeout);}
|
|
|
void setMonSourceIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceIndex(sidx, index, timeout);}
|
|
|
void setMonDestIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonDestIndex(sidx, index, timeout);}
|
|
|
void setMonOffset(int sidx, long offset, long timeout = DEF_TIMEOUT) {DsaBase::setMonOffset(sidx, offset, timeout);}
|
|
|
void setMonGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setMonGain(sidx, gain, timeout);}
|
|
|
void setXAnalogOffset(int sidx, double offset, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOffset(sidx, offset, timeout);}
|
|
|
void setXAnalogGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogGain(sidx, gain, timeout);}
|
|
|
void setSyncroInputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputMask(mask, timeout);}
|
|
|
void setSyncroInputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputValue(mask, timeout);}
|
|
|
void setSyncroOutputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputMask(mask, timeout);}
|
|
|
void setSyncroOutputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputValue(mask, timeout);}
|
|
|
void setSyncroStartTimeout(int tim, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroStartTimeout(tim, timeout);}
|
|
|
void setDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setDigitalOutput(out, timeout);}
|
|
|
void setXDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setXDigitalOutput(out, timeout);}
|
|
|
void setXAnalogOutput1(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput1(out, timeout);}
|
|
|
void setXAnalogOutput2(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput2(out, timeout);}
|
|
|
void setXAnalogOutput3(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput3(out, timeout);}
|
|
|
void setXAnalogOutput4(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput4(out, timeout);}
|
|
|
void setAnalogOutput(double out, long timeout = DEF_TIMEOUT) {DsaBase::setAnalogOutput(out, timeout);}
|
|
|
void setInterruptMask1(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask1(sidx, mask, timeout);}
|
|
|
void setInterruptMask2(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask2(sidx, mask, timeout);}
|
|
|
void setTriggerIrqMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIrqMask(mask, timeout);}
|
|
|
void setTriggerIOMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIOMask(mask, timeout);}
|
|
|
void setTriggerMapOffset(int offset, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapOffset(offset, timeout);}
|
|
|
void setTriggerMapSize(int size, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapSize(size, timeout);}
|
|
|
void setRealtimeEnabledGlobal(int enable, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledGlobal(enable, timeout);}
|
|
|
void setRealtimeValidMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeValidMask(mask, timeout);}
|
|
|
void setRealtimeEnabledMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledMask(mask, timeout);}
|
|
|
void setRealtimePendingMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimePendingMask(mask, timeout);}
|
|
|
void setEblBaudrate(long baud, long timeout = DEF_TIMEOUT) {DsaBase::setEblBaudrate(baud, timeout);}
|
|
|
void setIndirectAxisNumber(int axis, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectAxisNumber(axis, timeout);}
|
|
|
void setIndirectRegisterIdx(int idx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterIdx(idx, timeout);}
|
|
|
void setIndirectRegisterSidx(int sidx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterSidx(sidx, timeout);}
|
|
|
void setConcatenatedMvt(int concat, long timeout = DEF_TIMEOUT) {DsaBase::setConcatenatedMvt(concat, timeout);}
|
|
|
void setProfileType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setProfileType(sidx, typ, timeout);}
|
|
|
void setMvtLktNumber(int sidx, int number, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktNumber(sidx, number, timeout);}
|
|
|
void setMvtLktTime(int sidx, double time, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktTime(sidx, time, timeout);}
|
|
|
void setCameValue(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCameValue(factor, timeout);}
|
|
|
void setBrakeDeceleration(double dec, long timeout = DEF_TIMEOUT) {DsaBase::setBrakeDeceleration(dec, timeout);}
|
|
|
void setTargetPosition(int sidx, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTargetPosition(sidx, pos, timeout);}
|
|
|
void setProfileVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setProfileVelocity(sidx, vel, timeout);}
|
|
|
void setProfileAcceleration(int sidx, double acc, long timeout = DEF_TIMEOUT) {DsaBase::setProfileAcceleration(sidx, acc, timeout);}
|
|
|
void setJerkTime(int sidx, double tim, long timeout = DEF_TIMEOUT) {DsaBase::setJerkTime(sidx, tim, timeout);}
|
|
|
void setProfileDeceleration(int sidx, double dec, long timeout = DEF_TIMEOUT) {DsaBase::setProfileDeceleration(sidx, dec, timeout);}
|
|
|
void setEndVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setEndVelocity(sidx, vel, timeout);}
|
|
|
void setCtrlSourceType(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceType(typ, timeout);}
|
|
|
void setCtrlSourceIndex(int index, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceIndex(index, timeout);}
|
|
|
void setCtrlShiftFactor(int shift, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlShiftFactor(shift, timeout);}
|
|
|
void setCtrlOffset(long offset, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlOffset(offset, timeout);}
|
|
|
void setCtrlGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlGain(gain, timeout);}
|
|
|
void setMotorKTFactor(double kt, long timeout = DEF_TIMEOUT) {DsaBase::setMotorKTFactor(kt, timeout);}
|
|
|
|
|
|
void setPLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLProportionalGain(gain, handler, param);}
|
|
|
void setPLSpeedFeedbackGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedbackGain(gain, handler, param);}
|
|
|
void setPLForceFeedbackGain1(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain1(gain, handler, param);}
|
|
|
void setPLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorGain(gain, handler, param);}
|
|
|
void setPLAntiWindupGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLAntiWindupGain(gain, handler, param);}
|
|
|
void setPLIntegratorLimitation(double limit, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorLimitation(limit, handler, param);}
|
|
|
void setPLIntegratorMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorMode(mode, handler, param);}
|
|
|
void setPLSpeedFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFilter(tim, handler, param);}
|
|
|
void setPLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLOutputFilter(tim, handler, param);}
|
|
|
void setCLInputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLInputFilter(tim, handler, param);}
|
|
|
void setTtlSpecialFilter(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setTtlSpecialFilter(factor, handler, param);}
|
|
|
void setPLForceFeedbackGain2(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain2(factor, handler, param);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedfwdGain(factor, handler, param);}
|
|
|
void setPLAccFeedforwardGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLAccFeedforwardGain(factor, handler, param);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceFactor(factor, handler, param);}
|
|
|
void setAprInputFilter(double time, DsaHandler handler, void *param = NULL) {DsaBase::setAprInputFilter(time, handler, param);}
|
|
|
void setCLPhaseAdvanceShift(double shift, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceShift(shift, handler, param);}
|
|
|
void setMinPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxProfileVelocity(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setMaxProfileVelocity(vel, handler, param);}
|
|
|
void setMaxAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setMaxAcceleration(acc, handler, param);}
|
|
|
void startMovement(double *targets, DsaHandler handler, void *param = NULL) {DsaBase::startMovement(targets, handler, param);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setFollowingErrorWindow(pos, handler, param);}
|
|
|
void setVelocityErrorLimit(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setVelocityErrorLimit(vel, handler, param);}
|
|
|
void setSwitchLimitMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setSwitchLimitMode(mode, handler, param);}
|
|
|
void setEnableInputMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setEnableInputMode(mode, handler, param);}
|
|
|
void setMinSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinSoftPositionLimit(pos, handler, param);}
|
|
|
void setMaxSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxSoftPositionLimit(pos, handler, param);}
|
|
|
void setProfileLimitMode(dword flags, DsaHandler handler, void *param = NULL) {DsaBase::setProfileLimitMode(flags, handler, param);}
|
|
|
void setIOErrorEventMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setIOErrorEventMask(mask, handler, param);}
|
|
|
void setPositionWindowTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindowTime(tim, handler, param);}
|
|
|
void setPositionWindow(double win, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindow(win, handler, param);}
|
|
|
void setHomingMethod(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingMethod(mode, handler, param);}
|
|
|
void setHomingZeroSpeed(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setHomingZeroSpeed(vel, handler, param);}
|
|
|
void setHomingAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setHomingAcceleration(acc, handler, param);}
|
|
|
void setHomingFollowingLimit(double win, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFollowingLimit(win, handler, param);}
|
|
|
void setHomingCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setHomingCurrentLimit(cur, handler, param);}
|
|
|
void setHomeOffset(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomeOffset(pos, handler, param);}
|
|
|
void setHomingFixedMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFixedMvt(pos, handler, param);}
|
|
|
void setHomingSwitchMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingSwitchMvt(pos, handler, param);}
|
|
|
void setHomingIndexMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingIndexMvt(pos, handler, param);}
|
|
|
void setHomingFineTuningMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningMode(mode, handler, param);}
|
|
|
void setHomingFineTuningValue(double phase, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningValue(phase, handler, param);}
|
|
|
void setMotorPhaseCorrection(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setMotorPhaseCorrection(mode, handler, param);}
|
|
|
void setSoftwareCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setSoftwareCurrentLimit(cur, handler, param);}
|
|
|
void setDriveControlMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDriveControlMode(mode, handler, param);}
|
|
|
void setDisplayMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDisplayMode(mode, handler, param);}
|
|
|
void setEncoderInversion(double invert, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderInversion(invert, handler, param);}
|
|
|
void setPdrStepValue(double step, DsaHandler handler, void *param = NULL) {DsaBase::setPdrStepValue(step, handler, param);}
|
|
|
void setEncoderPhase1Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Offset(offset, handler, param);}
|
|
|
void setEncoderPhase2Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Offset(offset, handler, param);}
|
|
|
void setEncoderPhase1Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Factor(factor, handler, param);}
|
|
|
void setEncoderPhase2Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Factor(factor, handler, param);}
|
|
|
void setEncoderPhase3Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Offset(offset, handler, param);}
|
|
|
void setEncoderIndexDistance(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderIndexDistance(pos, handler, param);}
|
|
|
void setEncoderPhase3Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Factor(factor, handler, param);}
|
|
|
void setCLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLProportionalGain(gain, handler, param);}
|
|
|
void setCLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLIntegratorGain(gain, handler, param);}
|
|
|
void setCLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLOutputFilter(tim, handler, param);}
|
|
|
void setCLCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tTimeLimit(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tTimeLimit(tim, handler, param);}
|
|
|
void setCLRegenMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setCLRegenMode(mode, handler, param);}
|
|
|
void setInitMode(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setInitMode(typ, handler, param);}
|
|
|
void setInitPulseLevel(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitPulseLevel(cur, handler, param);}
|
|
|
void setInitMaxCurrent(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitMaxCurrent(cur, handler, param);}
|
|
|
void setInitFinalPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitFinalPhase(cal, handler, param);}
|
|
|
void setInitTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setInitTime(tim, handler, param);}
|
|
|
void setInitCurrentRate(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitCurrentRate(cur, handler, param);}
|
|
|
void setInitPhaseRate(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitPhaseRate(cal, handler, param);}
|
|
|
void setInitInitialPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitInitialPhase(cal, handler, param);}
|
|
|
void setDriveFuseChecking(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setDriveFuseChecking(mask, handler, param);}
|
|
|
void setMotorTempChecking(dword val, DsaHandler handler, void *param = NULL) {DsaBase::setMotorTempChecking(val, handler, param);}
|
|
|
void setMonSourceType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceType(sidx, typ, handler, param);}
|
|
|
void setMonSourceIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceIndex(sidx, index, handler, param);}
|
|
|
void setMonDestIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonDestIndex(sidx, index, handler, param);}
|
|
|
void setMonOffset(int sidx, long offset, DsaHandler handler, void *param = NULL) {DsaBase::setMonOffset(sidx, offset, handler, param);}
|
|
|
void setMonGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setMonGain(sidx, gain, handler, param);}
|
|
|
void setXAnalogOffset(int sidx, double offset, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOffset(sidx, offset, handler, param);}
|
|
|
void setXAnalogGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogGain(sidx, gain, handler, param);}
|
|
|
void setSyncroInputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputMask(mask, handler, param);}
|
|
|
void setSyncroInputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputValue(mask, handler, param);}
|
|
|
void setSyncroOutputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputMask(mask, handler, param);}
|
|
|
void setSyncroOutputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputValue(mask, handler, param);}
|
|
|
void setSyncroStartTimeout(int tim, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroStartTimeout(tim, handler, param);}
|
|
|
void setDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setDigitalOutput(out, handler, param);}
|
|
|
void setXDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setXDigitalOutput(out, handler, param);}
|
|
|
void setXAnalogOutput1(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput1(out, handler, param);}
|
|
|
void setXAnalogOutput2(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput2(out, handler, param);}
|
|
|
void setXAnalogOutput3(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput3(out, handler, param);}
|
|
|
void setXAnalogOutput4(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput4(out, handler, param);}
|
|
|
void setAnalogOutput(double out, DsaHandler handler, void *param = NULL) {DsaBase::setAnalogOutput(out, handler, param);}
|
|
|
void setInterruptMask1(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask1(sidx, mask, handler, param);}
|
|
|
void setInterruptMask2(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask2(sidx, mask, handler, param);}
|
|
|
void setTriggerIrqMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIrqMask(mask, handler, param);}
|
|
|
void setTriggerIOMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIOMask(mask, handler, param);}
|
|
|
void setTriggerMapOffset(int offset, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapOffset(offset, handler, param);}
|
|
|
void setTriggerMapSize(int size, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapSize(size, handler, param);}
|
|
|
void setRealtimeEnabledGlobal(int enable, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledGlobal(enable, handler, param);}
|
|
|
void setRealtimeValidMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeValidMask(mask, handler, param);}
|
|
|
void setRealtimeEnabledMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledMask(mask, handler, param);}
|
|
|
void setRealtimePendingMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimePendingMask(mask, handler, param);}
|
|
|
void setEblBaudrate(long baud, DsaHandler handler, void *param = NULL) {DsaBase::setEblBaudrate(baud, handler, param);}
|
|
|
void setIndirectAxisNumber(int axis, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectAxisNumber(axis, handler, param);}
|
|
|
void setIndirectRegisterIdx(int idx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterIdx(idx, handler, param);}
|
|
|
void setIndirectRegisterSidx(int sidx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterSidx(sidx, handler, param);}
|
|
|
void setConcatenatedMvt(int concat, DsaHandler handler, void *param = NULL) {DsaBase::setConcatenatedMvt(concat, handler, param);}
|
|
|
void setProfileType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setProfileType(sidx, typ, handler, param);}
|
|
|
void setMvtLktNumber(int sidx, int number, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktNumber(sidx, number, handler, param);}
|
|
|
void setMvtLktTime(int sidx, double time, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktTime(sidx, time, handler, param);}
|
|
|
void setCameValue(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCameValue(factor, handler, param);}
|
|
|
void setBrakeDeceleration(double dec, DsaHandler handler, void *param = NULL) {DsaBase::setBrakeDeceleration(dec, handler, param);}
|
|
|
void setTargetPosition(int sidx, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTargetPosition(sidx, pos, handler, param);}
|
|
|
void setProfileVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setProfileVelocity(sidx, vel, handler, param);}
|
|
|
void setProfileAcceleration(int sidx, double acc, DsaHandler handler, void *param = NULL) {DsaBase::setProfileAcceleration(sidx, acc, handler, param);}
|
|
|
void setJerkTime(int sidx, double tim, DsaHandler handler, void *param = NULL) {DsaBase::setJerkTime(sidx, tim, handler, param);}
|
|
|
void setProfileDeceleration(int sidx, double dec, DsaHandler handler, void *param = NULL) {DsaBase::setProfileDeceleration(sidx, dec, handler, param);}
|
|
|
void setEndVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setEndVelocity(sidx, vel, handler, param);}
|
|
|
void setCtrlSourceType(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceType(typ, handler, param);}
|
|
|
void setCtrlSourceIndex(int index, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceIndex(index, handler, param);}
|
|
|
void setCtrlShiftFactor(int shift, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlShiftFactor(shift, handler, param);}
|
|
|
void setCtrlOffset(long offset, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlOffset(offset, handler, param);}
|
|
|
void setCtrlGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlGain(gain, handler, param);}
|
|
|
void setMotorKTFactor(double kt, DsaHandler handler, void *param = NULL) {DsaBase::setMotorKTFactor(kt, handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaRTVData class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaRTVData {
|
|
|
protected:
|
|
|
DSA_RTV_DATA *rtvData;
|
|
|
int typ;
|
|
|
bool destroy;
|
|
|
/* constructors */
|
|
|
public:
|
|
|
DsaRTVData(DsaDevice dev, int regTyp, int regIdx, int regSidx) {
|
|
|
rtvData = NULL;
|
|
|
typ = READ_RTV_DATA;
|
|
|
destroy = TRUE;
|
|
|
ERRCHK(dsa_create_rtv_read(dev.getDsaStructure(), regTyp, regIdx, regSidx, &rtvData));
|
|
|
}
|
|
|
DsaRTVData(DsaDevice dev, int incrementTyp) {
|
|
|
rtvData = NULL;
|
|
|
typ = WRITE_RTV_DATA;
|
|
|
destroy = TRUE;
|
|
|
ERRCHK(dsa_create_rtv_write(dev.getDsaStructure(), incrementTyp, &rtvData));
|
|
|
}
|
|
|
DsaRTVData(DSA_RTV_DATA *rtvData) {
|
|
|
this->rtvData = rtvData;
|
|
|
destroy = FALSE;
|
|
|
if (dsa_is_read_rtv(rtvData))
|
|
|
typ = READ_RTV_DATA;
|
|
|
else
|
|
|
typ = WRITE_RTV_DATA;
|
|
|
}
|
|
|
public:
|
|
|
~DsaRTVData(void) {
|
|
|
if (destroy && rtvData)
|
|
|
ERRCHK(dsa_destroy_rtv(&rtvData));
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
/*
|
|
|
* RTV_DATA typ
|
|
|
*/
|
|
|
enum {READ_RTV_DATA = 0}; /*Read RTV data */
|
|
|
enum {WRITE_RTV_DATA = 1}; /*Write RTV data */
|
|
|
|
|
|
|
|
|
public:
|
|
|
DSA_RTV_DATA* getRTVDataStructure() {
|
|
|
return rtvData;
|
|
|
}
|
|
|
int readInt32() {
|
|
|
int value;
|
|
|
ERRCHK(dsa_read_rtv_int32(rtvData, &value));
|
|
|
return value;
|
|
|
}
|
|
|
eint64 readInt64() {
|
|
|
eint64 value;
|
|
|
ERRCHK(dsa_read_rtv_int64(rtvData, &value));
|
|
|
return value;
|
|
|
}
|
|
|
float readFloat32() {
|
|
|
float value;
|
|
|
ERRCHK(dsa_read_rtv_float32(rtvData, &value));
|
|
|
return value;
|
|
|
}
|
|
|
double readFloat64() {
|
|
|
double value;
|
|
|
ERRCHK(dsa_read_rtv_float64(rtvData, &value));
|
|
|
return value;
|
|
|
}
|
|
|
void writeInt32(int value) {
|
|
|
ERRCHK(dsa_write_rtv_int32(rtvData, value));
|
|
|
}
|
|
|
void writeInt64(eint64 value) {
|
|
|
ERRCHK(dsa_write_rtv_int64(rtvData, value));
|
|
|
}
|
|
|
void writeFloat32(float value) {
|
|
|
ERRCHK(dsa_write_rtv_float32(rtvData, value));
|
|
|
}
|
|
|
void writeFloat64(double value) {
|
|
|
ERRCHK(dsa_write_rtv_float64(rtvData, value));
|
|
|
}
|
|
|
bool isRead() {
|
|
|
return dsa_is_read_rtv(rtvData);
|
|
|
}
|
|
|
bool isWrite() {
|
|
|
return dsa_is_write_rtv(rtvData);
|
|
|
}
|
|
|
bool isInt32() {
|
|
|
return dsa_is_int32_rtv(rtvData);
|
|
|
}
|
|
|
bool isInt64() {
|
|
|
return dsa_is_int64_rtv(rtvData);
|
|
|
}
|
|
|
bool isFloat32() {
|
|
|
return dsa_is_float32_rtv(rtvData);
|
|
|
}
|
|
|
bool isFloat64() {
|
|
|
return dsa_is_float64_rtv(rtvData);
|
|
|
}
|
|
|
int getRegisterTyp() {
|
|
|
int value;
|
|
|
ERRCHK(dsa_get_register_typ_idx_sidx_rtv(rtvData, &value, NULL, NULL));
|
|
|
return value;
|
|
|
}
|
|
|
int getRegisterIdx() {
|
|
|
int value;
|
|
|
ERRCHK(dsa_get_register_typ_idx_sidx_rtv(rtvData, NULL, &value, NULL));
|
|
|
return value;
|
|
|
}
|
|
|
int getRegisterSidx() {
|
|
|
int value;
|
|
|
ERRCHK(dsa_get_register_typ_idx_sidx_rtv(rtvData, NULL, NULL, &value));
|
|
|
return value;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDsmaxBase class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDsmaxBase: public DsaBase {
|
|
|
/* constructors */
|
|
|
protected:
|
|
|
DsaDsmaxBase(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaDsmaxBase(DsaDsmaxBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDsmaxBase(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_dsmax_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaDsmaxBase operator = (DsaDsmaxBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDsmaxBase operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_dsmax_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDsmax class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDsmax: public DsaBase {
|
|
|
private:
|
|
|
DSA_RTV_DATA *readTable[64];
|
|
|
DSA_RTV_DATA *writeTable[64];
|
|
|
/* constructors */
|
|
|
public:
|
|
|
DsaDsmax(void) {
|
|
|
dsa = NULL;
|
|
|
ERRCHK(dsa_create_dsmax(&dsa));
|
|
|
}
|
|
|
DsaDsmax(DsaDsmax &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDsmax(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_dsmax(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaDsmax operator = (DsaDsmax &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDsmax operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_dsmax(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
int getWarningCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getWarningCode(kind, timeout);}
|
|
|
int getErrorCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getErrorCode(kind, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
long getRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegister(typ, idx, sidx, kind, timeout);}
|
|
|
long getRegisterInt32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt32(typ, idx, sidx, kind, timeout);}
|
|
|
eint64 getRegisterInt64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt64(typ, idx, sidx, kind, timeout);}
|
|
|
float getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat32(typ, idx, sidx, kind, timeout);}
|
|
|
double getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat64(typ, idx, sidx, kind, timeout);}
|
|
|
float getFloatRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getFloatRegister(typ, idx, sidx, kind, timeout);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
double getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, timeout);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout = DEF_TIMEOUT) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, timeout);}
|
|
|
DsaStatus waitStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusChange(DsaStatus *mask, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusChange(mask, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void getWarningCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getWarningCode(kind, handler, param);}
|
|
|
void getErrorCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getErrorCode(kind, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void getRegister(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt32(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegisterInt32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt64(int typ, unsigned idx, int sidx, int kind, DsaInt64Handler handler, void *param = NULL) {DsaBase::getRegisterInt64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, DsaFloatHandler handler, void *param = NULL) {DsaBase::getRegisterFloat32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRegisterFloat64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getFloatRegister(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFloatRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, handler, param);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, Dsa2intHandler handler, void *param = NULL) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, handler, param);}
|
|
|
void waitStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusEqual(mask, ref, handler, param);}
|
|
|
void waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void waitStatusChange(DsaStatus *mask, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusChange(mask, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void open(EtbBus etb, int axis) {DsaBase::open(etb, axis);}
|
|
|
void etcomOpen(EtbBus etb, int axis) {DsaBase::etcomOpen(etb, axis);}
|
|
|
void open(char_cp url) {DsaBase::open(url);}
|
|
|
void open(EtbBus etb, int axis, dword flags) {DsaBase::open(etb, axis, flags);}
|
|
|
void etcomOpen(EtbBus etb, int axis, dword flags) {DsaBase::etcomOpen(etb, axis, flags);}
|
|
|
void reset() {DsaBase::reset();}
|
|
|
void close() {DsaBase::close();}
|
|
|
EtbBus getEtbBus() {return DsaBase::getEtbBus();}
|
|
|
int getEtbAxis() {return DsaBase::getEtbAxis();}
|
|
|
int etcomGetEtbAxis() {return DsaBase::etcomGetEtbAxis();}
|
|
|
bool isOpen() {return DsaBase::isOpen();}
|
|
|
int getMotorTyp() {return DsaBase::getMotorTyp();}
|
|
|
void getErrorText(char_p text, int size, int code) {DsaBase::getErrorText(text, size, code);}
|
|
|
void getWarningText(char_p text, int size, int code) {DsaBase::getWarningText(text, size, code);}
|
|
|
double convertToIso(long inc, int conv) {return DsaBase::convertToIso(inc, conv);}
|
|
|
double convertInt32ToIso(long inc, int conv) {return DsaBase::convertInt32ToIso(inc, conv);}
|
|
|
double convertInt64ToIso(eint64 inc, int conv) {return DsaBase::convertInt64ToIso(inc, conv);}
|
|
|
double convertFloat32ToIso(float inc, int conv) {return DsaBase::convertFloat32ToIso(inc, conv);}
|
|
|
double convertFloat64ToIso(double inc, int conv) {return DsaBase::convertFloat64ToIso(inc, conv);}
|
|
|
long convertFromIso(double iso, int conv) {return DsaBase::convertFromIso(iso, conv);}
|
|
|
long convertInt32FromIso(double iso, int conv) {return DsaBase::convertInt32FromIso(iso, conv);}
|
|
|
eint64 convertInt64FromIso(double iso, int conv) {return DsaBase::convertInt64FromIso(iso, conv);}
|
|
|
float convertFloat32FromIso(double iso, int conv) {return DsaBase::convertFloat32FromIso(iso, conv);}
|
|
|
double convertFloat64FromIso(double iso, int conv) {return DsaBase::convertFloat64FromIso(iso, conv);}
|
|
|
double getIncToIsoFactor(int conv) {return DsaBase::getIncToIsoFactor(conv);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
DsaInfo getInfo() {return DsaBase::getInfo();}
|
|
|
DsaStatus getStatus() {return DsaBase::getStatus();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
DsaStatus getStatusFromDrive(long timeout = DEF_TIMEOUT) {return DsaBase::getStatusFromDrive(timeout);}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
double queryMinimumSampleTime() {return DsaBase::queryMinimumSampleTime();}
|
|
|
double querySampleTime(double time) {return DsaBase::querySampleTime(time);}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
DsaXInfo getXInfo() {return DsaBase::getXInfo();}
|
|
|
DmdData getDmdData() {return DsaBase::getDmdData();}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
void startUploadTrace(int traceTyp, int traceIdx, int startIdx, int endIdx, int stepIdx, bool fast, long timeout = DEF_TIMEOUT) {DsaBase::startUploadTrace(traceTyp, traceIdx, startIdx, endIdx, stepIdx, fast, timeout);}
|
|
|
void startUploadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startUploadSequence(timeout);}
|
|
|
void startUploadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startUploadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void uploadData(void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::uploadData(data, size, timeout);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void startRTVHandler(int nr, int rate, DsaRTVHandler handler, int nbRead, DsaRTVData *readRTV[], int nbWrite, DsaRTVData *writeRTV[], void *param = NULL) {
|
|
|
int i;
|
|
|
if ((nbRead < 0) || (nbRead > 64) || (nbWrite < 0) || (nbWrite > 64))
|
|
|
ERRCHK(DSA_EBADPARAM);
|
|
|
for (i = 0; i < nbRead; i++)
|
|
|
readTable[i] = readRTV[i]->getRTVDataStructure();
|
|
|
for (i = 0; i < nbWrite; i++)
|
|
|
writeTable[i] = writeRTV[i]->getRTVDataStructure();
|
|
|
ERRCHK(dsa_start_rtv_handler(DsaBase::dsa, nr, rate, *(DSA_RTV_HANDLER*)&handler, nbRead, readTable, nbWrite, writeTable, param));
|
|
|
}
|
|
|
void stopRTVHandler(int nr) {
|
|
|
ERRCHK(dsa_stop_rtv_handler(DsaBase::dsa, nr));
|
|
|
}
|
|
|
bool isRTVHandlerActive(int nr) {
|
|
|
bool active;
|
|
|
ERRCHK(dsa_get_rtv_handler_activity(DsaBase::dsa, nr, &active));
|
|
|
return active;
|
|
|
}
|
|
|
void setWatchdog(double ms) {
|
|
|
ERRCHK(dsa_set_watchdog(DsaBase::dsa, ms));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaDsmaxGroup class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaDsmaxGroup: public DsaBase {
|
|
|
/* constructors */
|
|
|
private:
|
|
|
void _Group(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_dsmax_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
protected:
|
|
|
DsaDsmaxGroup(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaDsmaxGroup(DsaDsmaxGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_dsmax_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaDsmaxGroup(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_dsmax_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
DsaDsmaxGroup(int max, DsaDriveBase *list[]) {
|
|
|
ERRCHK(dsa_create_dsmax_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, list[i]->dsa));
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2) {
|
|
|
_Group(2, &d1, &d2);
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3) {
|
|
|
_Group(3, &d1, &d2, &d3);
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4) {
|
|
|
_Group(4, &d1, &d2, &d3, &d4);
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5) {
|
|
|
_Group(5, &d1, &d2, &d3, &d4, &d5);
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6) {
|
|
|
_Group(6, &d1, &d2, &d3, &d4, &d5, &d6);
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6, DsaDriveBase d7) {
|
|
|
_Group(7, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
|
|
}
|
|
|
DsaDsmaxGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6, DsaDriveBase d7, DsaDriveBase d8) {
|
|
|
_Group(8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8);
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaDsmaxGroup operator = (DsaDsmaxGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaDsmaxGroup operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_dsmax_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
int getGroupSize() {return DsaBase::getGroupSize();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaIpolGroup class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaIpolGroup: public DsaBase {
|
|
|
/* constructors */
|
|
|
private:
|
|
|
void _Group(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_ipol_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
protected:
|
|
|
DsaIpolGroup(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaIpolGroup(DsaIpolGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaIpolGroup(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_ipol_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaIpolGroup(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_ipol_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
DsaIpolGroup(int max, DsaDriveBase *list[]) {
|
|
|
ERRCHK(dsa_create_ipol_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, list[i]->dsa));
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2) {
|
|
|
_Group(2, &d1, &d2);
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3) {
|
|
|
_Group(3, &d1, &d2, &d3);
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4) {
|
|
|
_Group(4, &d1, &d2, &d3, &d4);
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5) {
|
|
|
_Group(5, &d1, &d2, &d3, &d4, &d5);
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6) {
|
|
|
_Group(6, &d1, &d2, &d3, &d4, &d5, &d6);
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6, DsaDriveBase d7) {
|
|
|
_Group(7, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
|
|
}
|
|
|
DsaIpolGroup(DsaDriveBase d1, DsaDriveBase d2, DsaDriveBase d3, DsaDriveBase d4, DsaDriveBase d5, DsaDriveBase d6, DsaDriveBase d7, DsaDriveBase d8) {
|
|
|
_Group(8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8);
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaIpolGroup operator = (DsaIpolGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaIpolGroup operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_ipol_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
public:
|
|
|
DsaDriveBase getGroupItem(int pos) {return DsaBase::getGroupItem(pos);}
|
|
|
DsaDsmax getDsmax(void) {return DsaBase::getDsmax();}
|
|
|
void setDsmax(DsaDsmax dsmax) {DsaBase::setDsmax(dsmax);}
|
|
|
void powerOn(long timeout = DEF_TIMEOUT) {DsaBase::powerOn(timeout);}
|
|
|
void powerOff(long timeout = DEF_TIMEOUT) {DsaBase::powerOff(timeout);}
|
|
|
void newSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::newSetpoint(sidx, flags, timeout);}
|
|
|
void changeSetpoint(int sidx, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::changeSetpoint(sidx, flags, timeout);}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void homingStart(long timeout = DEF_TIMEOUT) {DsaBase::homingStart(timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, long timeout = DEF_TIMEOUT) {DsaBase::startProfiledMovement(pos, speed, acc, timeout);}
|
|
|
void startRelativeProfiledMovement(double relativePos, long timeout = DEF_TIMEOUT) {DsaBase::startRelativeProfiledMovement(relativePos, timeout);}
|
|
|
void stageMappingDownload(const char *fileName) {DsaBase::stageMappingDownload(fileName);}
|
|
|
void stageMappingUpload(const char *fileName) {DsaBase::stageMappingUpload(fileName);}
|
|
|
void stageMappingActivate() {DsaBase::stageMappingActivate();}
|
|
|
void stageMappingDeactivate() {DsaBase::stageMappingDeactivate();}
|
|
|
bool stageMappingIsActivated() {return DsaBase::stageMappingIsActivated();}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void ipolBegin(long timeout = DEF_TIMEOUT) {DsaBase::ipolBegin(timeout);}
|
|
|
void ipolEnd(long timeout = DEF_TIMEOUT) {DsaBase::ipolEnd(timeout);}
|
|
|
void ipolBeginConcatenation(long timeout = DEF_TIMEOUT) {DsaBase::ipolBeginConcatenation(timeout);}
|
|
|
void ipolEndConcatenation(long timeout = DEF_TIMEOUT) {DsaBase::ipolEndConcatenation(timeout);}
|
|
|
void ipolLine(DsaVector *dest, long timeout = DEF_TIMEOUT) {DsaBase::ipolLine(dest, timeout);}
|
|
|
void ipolCircleCWR2d(double x, double y, double r, long timeout = DEF_TIMEOUT) {DsaBase::ipolCircleCWR2d(x, y, r, timeout);}
|
|
|
void ipolCircleCcwR2d(double x, double y, double r, long timeout = DEF_TIMEOUT) {DsaBase::ipolCircleCcwR2d(x, y, r, timeout);}
|
|
|
void ipolTanVelocity(double velocity, long timeout = DEF_TIMEOUT) {DsaBase::ipolTanVelocity(velocity, timeout);}
|
|
|
void ipolTanAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::ipolTanAcceleration(acc, timeout);}
|
|
|
void ipolTanDeceleration(double dec, long timeout = DEF_TIMEOUT) {DsaBase::ipolTanDeceleration(dec, timeout);}
|
|
|
void ipolTanJerkTime(double jerk_time, long timeout = DEF_TIMEOUT) {DsaBase::ipolTanJerkTime(jerk_time, timeout);}
|
|
|
void ipolQuickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::ipolQuickStop(mode, flags, timeout);}
|
|
|
void ipolContinue(long timeout = DEF_TIMEOUT) {DsaBase::ipolContinue(timeout);}
|
|
|
void ipolReset(long timeout = DEF_TIMEOUT) {DsaBase::ipolReset(timeout);}
|
|
|
void ipolPvt(DsaVector *dest, DsaVector *velocity, double time, long timeout = DEF_TIMEOUT) {DsaBase::ipolPvt(dest, velocity, time, timeout);}
|
|
|
void ipolMark(long number, long operation, long op_param, long timeout = DEF_TIMEOUT) {DsaBase::ipolMark(number, operation, op_param, timeout);}
|
|
|
void ipolMark2Param(long number, long operation, long op_param1, long op_param2, long timeout = DEF_TIMEOUT) {DsaBase::ipolMark2Param(number, operation, op_param1, op_param2, timeout);}
|
|
|
void ipolSetVelocityRate(double rate, long timeout = DEF_TIMEOUT) {DsaBase::ipolSetVelocityRate(rate, timeout);}
|
|
|
void ipolCircleCWC2d(double x, double y, double cx, double cy, long timeout = DEF_TIMEOUT) {DsaBase::ipolCircleCWC2d(x, y, cx, cy, timeout);}
|
|
|
void ipolCircleCcwC2d(double x, double y, double cx, double cy, long timeout = DEF_TIMEOUT) {DsaBase::ipolCircleCcwC2d(x, y, cx, cy, timeout);}
|
|
|
void ipolLine(double x, double y, long timeout = DEF_TIMEOUT) {DsaBase::ipolLine(x, y, timeout);}
|
|
|
void ipolWaitMovement(long timeout = DEF_TIMEOUT) {DsaBase::ipolWaitMovement(timeout);}
|
|
|
void ipolPrepare(long timeout = DEF_TIMEOUT) {DsaBase::ipolPrepare(timeout);}
|
|
|
void ipolPvtUpdate(int depth, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::ipolPvtUpdate(depth, mask, timeout);}
|
|
|
void ipolPvtRegTyp(DsaVector *dest, DsaVectorTyp destTyp, DsaVector *velocity, DsaVectorTyp velocityTyp, double time, int timeTyp, long timeout = DEF_TIMEOUT) {DsaBase::ipolPvtRegTyp(dest, destTyp, velocity, velocityTyp, time, timeTyp, timeout);}
|
|
|
void ipolSetLktSpeedRatio(double value, long timeout = DEF_TIMEOUT) {DsaBase::ipolSetLktSpeedRatio(value, timeout);}
|
|
|
void ipolSetLktCyclicMode(bool active, long timeout = DEF_TIMEOUT) {DsaBase::ipolSetLktCyclicMode(active, timeout);}
|
|
|
void ipolSetLktRelativeMode(bool active, long timeout = DEF_TIMEOUT) {DsaBase::ipolSetLktRelativeMode(active, timeout);}
|
|
|
void ipolLkt(DsaVector *dest, DsaIntVector *lkt_number, double time, long timeout = DEF_TIMEOUT) {DsaBase::ipolLkt(dest, lkt_number, time, timeout);}
|
|
|
void ipolWaitMark(int mark, long timeout = DEF_TIMEOUT) {DsaBase::ipolWaitMark(mark, timeout);}
|
|
|
void ipolUline(DsaVector *dest, long timeout = DEF_TIMEOUT) {DsaBase::ipolUline(dest, timeout);}
|
|
|
void ipolUline(double x, double y, long timeout = DEF_TIMEOUT) {DsaBase::ipolUline(x, y, timeout);}
|
|
|
void ipolDisableUconcatenation(long timeout = DEF_TIMEOUT) {DsaBase::ipolDisableUconcatenation(timeout);}
|
|
|
void ipolSetUrelativeMode(bool active, long timeout = DEF_TIMEOUT) {DsaBase::ipolSetUrelativeMode(active, timeout);}
|
|
|
void ipolUspeedAxisMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::ipolUspeedAxisMask(mask, timeout);}
|
|
|
void ipolUspeed(double speed, long timeout = DEF_TIMEOUT) {DsaBase::ipolUspeed(speed, timeout);}
|
|
|
void ipolUtime(double acc_time, double jerk_time, long timeout = DEF_TIMEOUT) {DsaBase::ipolUtime(acc_time, jerk_time, timeout);}
|
|
|
void ipolTranslateMatrix(DsaVector *trans, long timeout = DEF_TIMEOUT) {DsaBase::ipolTranslateMatrix(trans, timeout);}
|
|
|
void ipolScaleMatrix(DsaVector *scale, long timeout = DEF_TIMEOUT) {DsaBase::ipolScaleMatrix(scale, timeout);}
|
|
|
void ipolRotateMatrix(int plan, double degree, long timeout = DEF_TIMEOUT) {DsaBase::ipolRotateMatrix(plan, degree, timeout);}
|
|
|
void ipolTranslateMatrix(double x, double y, long timeout = DEF_TIMEOUT) {DsaBase::ipolTranslateMatrix(x, y, timeout);}
|
|
|
void ipolScaleMatrix(double x, double y, long timeout = DEF_TIMEOUT) {DsaBase::ipolScaleMatrix(x, y, timeout);}
|
|
|
void ipolShearMatrix(int sheared_axis, double axis1_shearing, double axis2_shearing, double axis3_shearing, long timeout = DEF_TIMEOUT) {DsaBase::ipolShearMatrix(sheared_axis, axis1_shearing, axis2_shearing, axis3_shearing, timeout);}
|
|
|
void ipolLock(long timeout = DEF_TIMEOUT) {DsaBase::ipolLock(timeout);}
|
|
|
void ipolUnlock(long timeout = DEF_TIMEOUT) {DsaBase::ipolUnlock(timeout);}
|
|
|
int ipolGetIpolGroup() {return DsaBase::ipolGetIpolGroup();}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void powerOn(DsaHandler handler, void *param = NULL) {DsaBase::powerOn(handler, param);}
|
|
|
void powerOff(DsaHandler handler, void *param = NULL) {DsaBase::powerOff(handler, param);}
|
|
|
void newSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::newSetpoint(sidx, flags, handler, param);}
|
|
|
void changeSetpoint(int sidx, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::changeSetpoint(sidx, flags, handler, param);}
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void homingStart(DsaHandler handler, void *param = NULL) {DsaBase::homingStart(handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void startProfiledMovement(double pos, double speed, double acc, DsaHandler handler, void *param = NULL) {DsaBase::startProfiledMovement(pos, speed, acc, handler, param);}
|
|
|
void startRelativeProfiledMovement(double relativePos, DsaHandler handler, void *param = NULL) {DsaBase::startRelativeProfiledMovement(relativePos, handler, param);}
|
|
|
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void ipolBegin(DsaHandler handler, void *param = NULL) {DsaBase::ipolBegin(handler, param);}
|
|
|
void ipolEnd(DsaHandler handler, void *param = NULL) {DsaBase::ipolEnd(handler, param);}
|
|
|
void ipolBeginConcatenation(DsaHandler handler, void *param = NULL) {DsaBase::ipolBeginConcatenation(handler, param);}
|
|
|
void ipolEndConcatenation(DsaHandler handler, void *param = NULL) {DsaBase::ipolEndConcatenation(handler, param);}
|
|
|
void ipolLine(DsaVector *dest, DsaHandler handler, void *param = NULL) {DsaBase::ipolLine(dest, handler, param);}
|
|
|
void ipolCircleCWR2d(double x, double y, double r, DsaHandler handler, void *param = NULL) {DsaBase::ipolCircleCWR2d(x, y, r, handler, param);}
|
|
|
void ipolCircleCcwR2d(double x, double y, double r, DsaHandler handler, void *param = NULL) {DsaBase::ipolCircleCcwR2d(x, y, r, handler, param);}
|
|
|
void ipolTanVelocity(double velocity, DsaHandler handler, void *param = NULL) {DsaBase::ipolTanVelocity(velocity, handler, param);}
|
|
|
void ipolTanAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::ipolTanAcceleration(acc, handler, param);}
|
|
|
void ipolTanDeceleration(double dec, DsaHandler handler, void *param = NULL) {DsaBase::ipolTanDeceleration(dec, handler, param);}
|
|
|
void ipolTanJerkTime(double jerk_time, DsaHandler handler, void *param = NULL) {DsaBase::ipolTanJerkTime(jerk_time, handler, param);}
|
|
|
void ipolQuickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::ipolQuickStop(mode, flags, handler, param);}
|
|
|
void ipolContinue(DsaHandler handler, void *param = NULL) {DsaBase::ipolContinue(handler, param);}
|
|
|
void ipolReset(DsaHandler handler, void *param = NULL) {DsaBase::ipolReset(handler, param);}
|
|
|
void ipolPvt(DsaVector *dest, DsaVector *velocity, double time, DsaHandler handler, void *param = NULL) {DsaBase::ipolPvt(dest, velocity, time, handler, param);}
|
|
|
void ipolMark(long number, long operation, long op_param, DsaHandler handler, void *param = NULL) {DsaBase::ipolMark(number, operation, op_param, handler, param);}
|
|
|
void ipolMark2Param(long number, long operation, long op_param1, long op_param2, DsaHandler handler, void *param = NULL) {DsaBase::ipolMark2Param(number, operation, op_param1, op_param2, handler, param);}
|
|
|
void ipolSetVelocityRate(double rate, DsaHandler handler, void *param = NULL) {DsaBase::ipolSetVelocityRate(rate, handler, param);}
|
|
|
void ipolCircleCWC2d(double x, double y, double cx, double cy, DsaHandler handler, void *param = NULL) {DsaBase::ipolCircleCWC2d(x, y, cx, cy, handler, param);}
|
|
|
void ipolCircleCcwC2d(double x, double y, double cx, double cy, DsaHandler handler, void *param = NULL) {DsaBase::ipolCircleCcwC2d(x, y, cx, cy, handler, param);}
|
|
|
void ipolLine(double x, double y, DsaHandler handler, void *param = NULL) {DsaBase::ipolLine(x, y, handler, param);}
|
|
|
void ipolWaitMovement(DsaHandler handler, void *param = NULL) {DsaBase::ipolWaitMovement(handler, param);}
|
|
|
void ipolPrepare(DsaHandler handler, void *param = NULL) {DsaBase::ipolPrepare(handler, param);}
|
|
|
void ipolPvtUpdate(int depth, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::ipolPvtUpdate(depth, mask, handler, param);}
|
|
|
void ipolPvtRegTyp(DsaVector *dest, DsaVectorTyp destTyp, DsaVector *velocity, DsaVectorTyp velocityTyp, double time, int timeTyp, DsaHandler handler, void *param = NULL) {DsaBase::ipolPvtRegTyp(dest, destTyp, velocity, velocityTyp, time, timeTyp, handler, param);}
|
|
|
void ipolSetLktSpeedRatio(double value, DsaHandler handler, void *param = NULL) {DsaBase::ipolSetLktSpeedRatio(value, handler, param);}
|
|
|
void ipolSetLktCyclicMode(bool active, DsaHandler handler, void *param = NULL) {DsaBase::ipolSetLktCyclicMode(active, handler, param);}
|
|
|
void ipolSetLktRelativeMode(bool active, DsaHandler handler, void *param = NULL) {DsaBase::ipolSetLktRelativeMode(active, handler, param);}
|
|
|
void ipolLkt(DsaVector *dest, DsaIntVector *lkt_number, double time, DsaHandler handler, void *param = NULL) {DsaBase::ipolLkt(dest, lkt_number, time, handler, param);}
|
|
|
void ipolWaitMark(int mark, DsaHandler handler, void *param = NULL) {DsaBase::ipolWaitMark(mark, handler, param);}
|
|
|
void ipolUline(DsaVector *dest, DsaHandler handler, void *param = NULL) {DsaBase::ipolUline(dest, handler, param);}
|
|
|
void ipolUline(double x, double y, DsaHandler handler, void *param = NULL) {DsaBase::ipolUline(x, y, handler, param);}
|
|
|
void ipolDisableUconcatenation(DsaHandler handler, void *param = NULL) {DsaBase::ipolDisableUconcatenation(handler, param);}
|
|
|
void ipolSetUrelativeMode(bool active, DsaHandler handler, void *param = NULL) {DsaBase::ipolSetUrelativeMode(active, handler, param);}
|
|
|
void ipolUspeedAxisMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::ipolUspeedAxisMask(mask, handler, param);}
|
|
|
void ipolUspeed(double speed, DsaHandler handler, void *param = NULL) {DsaBase::ipolUspeed(speed, handler, param);}
|
|
|
void ipolUtime(double acc_time, double jerk_time, DsaHandler handler, void *param = NULL) {DsaBase::ipolUtime(acc_time, jerk_time, handler, param);}
|
|
|
void ipolTranslateMatrix(DsaVector *trans, DsaHandler handler, void *param = NULL) {DsaBase::ipolTranslateMatrix(trans, handler, param);}
|
|
|
void ipolScaleMatrix(DsaVector *scale, DsaHandler handler, void *param = NULL) {DsaBase::ipolScaleMatrix(scale, handler, param);}
|
|
|
void ipolRotateMatrix(int plan, double degree, DsaHandler handler, void *param = NULL) {DsaBase::ipolRotateMatrix(plan, degree, handler, param);}
|
|
|
void ipolTranslateMatrix(double x, double y, DsaHandler handler, void *param = NULL) {DsaBase::ipolTranslateMatrix(x, y, handler, param);}
|
|
|
void ipolScaleMatrix(double x, double y, DsaHandler handler, void *param = NULL) {DsaBase::ipolScaleMatrix(x, y, handler, param);}
|
|
|
void ipolShearMatrix(int sheared_axis, double axis1_shearing, double axis2_shearing, double axis3_shearing, DsaHandler handler, void *param = NULL) {DsaBase::ipolShearMatrix(sheared_axis, axis1_shearing, axis2_shearing, axis3_shearing, handler, param);}
|
|
|
void ipolLock(DsaHandler handler, void *param = NULL) {DsaBase::ipolLock(handler, param);}
|
|
|
void ipolUnlock(DsaHandler handler, void *param = NULL) {DsaBase::ipolUnlock(handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void getRtmMon(DsaRTM *rtm) {DsaBase::getRtmMon(rtm);}
|
|
|
void initRtmFct() {DsaBase::initRtmFct();}
|
|
|
void startRtm(DsaTrajectoryHandler fct) {DsaBase::startRtm(fct);}
|
|
|
void stopRtm() {DsaBase::stopRtm();}
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
int getGroupSize() {return DsaBase::getGroupSize();}
|
|
|
bool isIpolINProgress() {return DsaBase::isIpolINProgress();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void stepMotion(double pos, long timeout = DEF_TIMEOUT) {DsaBase::stepMotion(pos, timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void canCommand1(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand1(val1, val2, timeout);}
|
|
|
void canCommand2(dword val1, dword val2, long timeout = DEF_TIMEOUT) {DsaBase::canCommand2(val1, val2, timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
void startDownloadSequence(long timeout = DEF_TIMEOUT) {DsaBase::startDownloadSequence(timeout);}
|
|
|
void startDownloadRegister(int typ, int startIdx, int endIdx, int sidx, long timeout = DEF_TIMEOUT) {DsaBase::startDownloadRegister(typ, startIdx, endIdx, sidx, timeout);}
|
|
|
void downloadData(const void *data, int size, long timeout = DEF_TIMEOUT) {DsaBase::downloadData(data, size, timeout);}
|
|
|
void downloadCompiledSequenceFile(char *fileName) {DsaBase::downloadCompiledSequenceFile(fileName);}
|
|
|
void setSequenceVersion(char *fileName) {DsaBase::setSequenceVersion(fileName);}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void stepMotion(double pos, DsaHandler handler, void *param = NULL) {DsaBase::stepMotion(pos, handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void canCommand1(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand1(val1, val2, handler, param);}
|
|
|
void canCommand2(dword val1, dword val2, DsaHandler handler, void *param = NULL) {DsaBase::canCommand2(val1, val2, handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
|
|
|
/* register setters */
|
|
|
void setPLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLProportionalGain(gain, timeout);}
|
|
|
void setPLSpeedFeedbackGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedbackGain(gain, timeout);}
|
|
|
void setPLForceFeedbackGain1(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain1(gain, timeout);}
|
|
|
void setPLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorGain(gain, timeout);}
|
|
|
void setPLAntiWindupGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setPLAntiWindupGain(gain, timeout);}
|
|
|
void setPLIntegratorLimitation(double limit, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorLimitation(limit, timeout);}
|
|
|
void setPLIntegratorMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setPLIntegratorMode(mode, timeout);}
|
|
|
void setPLSpeedFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFilter(tim, timeout);}
|
|
|
void setPLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPLOutputFilter(tim, timeout);}
|
|
|
void setCLInputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLInputFilter(tim, timeout);}
|
|
|
void setTtlSpecialFilter(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setTtlSpecialFilter(factor, timeout);}
|
|
|
void setPLForceFeedbackGain2(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLForceFeedbackGain2(factor, timeout);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLSpeedFeedfwdGain(factor, timeout);}
|
|
|
void setPLAccFeedforwardGain(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setPLAccFeedforwardGain(factor, timeout);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceFactor(factor, timeout);}
|
|
|
void setAprInputFilter(double time, long timeout = DEF_TIMEOUT) {DsaBase::setAprInputFilter(time, timeout);}
|
|
|
void setCLPhaseAdvanceShift(double shift, long timeout = DEF_TIMEOUT) {DsaBase::setCLPhaseAdvanceShift(shift, timeout);}
|
|
|
void setMinPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxPositionRangeLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxPositionRangeLimit(pos, timeout);}
|
|
|
void setMaxProfileVelocity(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setMaxProfileVelocity(vel, timeout);}
|
|
|
void setMaxAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setMaxAcceleration(acc, timeout);}
|
|
|
void startMovement(double *targets, long timeout = DEF_TIMEOUT) {DsaBase::startMovement(targets, timeout);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setFollowingErrorWindow(pos, timeout);}
|
|
|
void setVelocityErrorLimit(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setVelocityErrorLimit(vel, timeout);}
|
|
|
void setSwitchLimitMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setSwitchLimitMode(mode, timeout);}
|
|
|
void setEnableInputMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setEnableInputMode(mode, timeout);}
|
|
|
void setMinSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMinSoftPositionLimit(pos, timeout);}
|
|
|
void setMaxSoftPositionLimit(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setMaxSoftPositionLimit(pos, timeout);}
|
|
|
void setProfileLimitMode(dword flags, long timeout = DEF_TIMEOUT) {DsaBase::setProfileLimitMode(flags, timeout);}
|
|
|
void setIOErrorEventMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setIOErrorEventMask(mask, timeout);}
|
|
|
void setPositionWindowTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindowTime(tim, timeout);}
|
|
|
void setPositionWindow(double win, long timeout = DEF_TIMEOUT) {DsaBase::setPositionWindow(win, timeout);}
|
|
|
void setHomingMethod(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingMethod(mode, timeout);}
|
|
|
void setHomingZeroSpeed(double vel, long timeout = DEF_TIMEOUT) {DsaBase::setHomingZeroSpeed(vel, timeout);}
|
|
|
void setHomingAcceleration(double acc, long timeout = DEF_TIMEOUT) {DsaBase::setHomingAcceleration(acc, timeout);}
|
|
|
void setHomingFollowingLimit(double win, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFollowingLimit(win, timeout);}
|
|
|
void setHomingCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setHomingCurrentLimit(cur, timeout);}
|
|
|
void setHomeOffset(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomeOffset(pos, timeout);}
|
|
|
void setHomingFixedMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFixedMvt(pos, timeout);}
|
|
|
void setHomingSwitchMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingSwitchMvt(pos, timeout);}
|
|
|
void setHomingIndexMvt(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setHomingIndexMvt(pos, timeout);}
|
|
|
void setHomingFineTuningMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningMode(mode, timeout);}
|
|
|
void setHomingFineTuningValue(double phase, long timeout = DEF_TIMEOUT) {DsaBase::setHomingFineTuningValue(phase, timeout);}
|
|
|
void setMotorPhaseCorrection(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setMotorPhaseCorrection(mode, timeout);}
|
|
|
void setSoftwareCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setSoftwareCurrentLimit(cur, timeout);}
|
|
|
void setDriveControlMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDriveControlMode(mode, timeout);}
|
|
|
void setDisplayMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setDisplayMode(mode, timeout);}
|
|
|
void setEncoderInversion(double invert, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderInversion(invert, timeout);}
|
|
|
void setPdrStepValue(double step, long timeout = DEF_TIMEOUT) {DsaBase::setPdrStepValue(step, timeout);}
|
|
|
void setEncoderPhase1Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Offset(offset, timeout);}
|
|
|
void setEncoderPhase2Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Offset(offset, timeout);}
|
|
|
void setEncoderPhase1Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase1Factor(factor, timeout);}
|
|
|
void setEncoderPhase2Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase2Factor(factor, timeout);}
|
|
|
void setEncoderPhase3Offset(double offset, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Offset(offset, timeout);}
|
|
|
void setEncoderIndexDistance(double pos, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderIndexDistance(pos, timeout);}
|
|
|
void setEncoderPhase3Factor(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setEncoderPhase3Factor(factor, timeout);}
|
|
|
void setCLProportionalGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLProportionalGain(gain, timeout);}
|
|
|
void setCLIntegratorGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCLIntegratorGain(gain, timeout);}
|
|
|
void setCLOutputFilter(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLOutputFilter(tim, timeout);}
|
|
|
void setCLCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tCurrentLimit(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tCurrentLimit(cur, timeout);}
|
|
|
void setCLI2tTimeLimit(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setCLI2tTimeLimit(tim, timeout);}
|
|
|
void setCLRegenMode(int mode, long timeout = DEF_TIMEOUT) {DsaBase::setCLRegenMode(mode, timeout);}
|
|
|
void setInitMode(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setInitMode(typ, timeout);}
|
|
|
void setInitPulseLevel(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitPulseLevel(cur, timeout);}
|
|
|
void setInitMaxCurrent(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitMaxCurrent(cur, timeout);}
|
|
|
void setInitFinalPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitFinalPhase(cal, timeout);}
|
|
|
void setInitTime(double tim, long timeout = DEF_TIMEOUT) {DsaBase::setInitTime(tim, timeout);}
|
|
|
void setInitCurrentRate(double cur, long timeout = DEF_TIMEOUT) {DsaBase::setInitCurrentRate(cur, timeout);}
|
|
|
void setInitPhaseRate(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitPhaseRate(cal, timeout);}
|
|
|
void setInitInitialPhase(double cal, long timeout = DEF_TIMEOUT) {DsaBase::setInitInitialPhase(cal, timeout);}
|
|
|
void setDriveFuseChecking(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setDriveFuseChecking(mask, timeout);}
|
|
|
void setMotorTempChecking(dword val, long timeout = DEF_TIMEOUT) {DsaBase::setMotorTempChecking(val, timeout);}
|
|
|
void setMonSourceType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceType(sidx, typ, timeout);}
|
|
|
void setMonSourceIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonSourceIndex(sidx, index, timeout);}
|
|
|
void setMonDestIndex(int sidx, int index, long timeout = DEF_TIMEOUT) {DsaBase::setMonDestIndex(sidx, index, timeout);}
|
|
|
void setMonOffset(int sidx, long offset, long timeout = DEF_TIMEOUT) {DsaBase::setMonOffset(sidx, offset, timeout);}
|
|
|
void setMonGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setMonGain(sidx, gain, timeout);}
|
|
|
void setXAnalogOffset(int sidx, double offset, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOffset(sidx, offset, timeout);}
|
|
|
void setXAnalogGain(int sidx, double gain, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogGain(sidx, gain, timeout);}
|
|
|
void setSyncroInputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputMask(mask, timeout);}
|
|
|
void setSyncroInputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroInputValue(mask, timeout);}
|
|
|
void setSyncroOutputMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputMask(mask, timeout);}
|
|
|
void setSyncroOutputValue(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroOutputValue(mask, timeout);}
|
|
|
void setSyncroStartTimeout(int tim, long timeout = DEF_TIMEOUT) {DsaBase::setSyncroStartTimeout(tim, timeout);}
|
|
|
void setDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setDigitalOutput(out, timeout);}
|
|
|
void setXDigitalOutput(dword out, long timeout = DEF_TIMEOUT) {DsaBase::setXDigitalOutput(out, timeout);}
|
|
|
void setXAnalogOutput1(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput1(out, timeout);}
|
|
|
void setXAnalogOutput2(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput2(out, timeout);}
|
|
|
void setXAnalogOutput3(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput3(out, timeout);}
|
|
|
void setXAnalogOutput4(double out, long timeout = DEF_TIMEOUT) {DsaBase::setXAnalogOutput4(out, timeout);}
|
|
|
void setAnalogOutput(double out, long timeout = DEF_TIMEOUT) {DsaBase::setAnalogOutput(out, timeout);}
|
|
|
void setInterruptMask1(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask1(sidx, mask, timeout);}
|
|
|
void setInterruptMask2(int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setInterruptMask2(sidx, mask, timeout);}
|
|
|
void setTriggerIrqMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIrqMask(mask, timeout);}
|
|
|
void setTriggerIOMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerIOMask(mask, timeout);}
|
|
|
void setTriggerMapOffset(int offset, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapOffset(offset, timeout);}
|
|
|
void setTriggerMapSize(int size, long timeout = DEF_TIMEOUT) {DsaBase::setTriggerMapSize(size, timeout);}
|
|
|
void setRealtimeEnabledGlobal(int enable, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledGlobal(enable, timeout);}
|
|
|
void setRealtimeValidMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeValidMask(mask, timeout);}
|
|
|
void setRealtimeEnabledMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimeEnabledMask(mask, timeout);}
|
|
|
void setRealtimePendingMask(dword mask, long timeout = DEF_TIMEOUT) {DsaBase::setRealtimePendingMask(mask, timeout);}
|
|
|
void setEblBaudrate(long baud, long timeout = DEF_TIMEOUT) {DsaBase::setEblBaudrate(baud, timeout);}
|
|
|
void setIndirectAxisNumber(int axis, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectAxisNumber(axis, timeout);}
|
|
|
void setIndirectRegisterIdx(int idx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterIdx(idx, timeout);}
|
|
|
void setIndirectRegisterSidx(int sidx, long timeout = DEF_TIMEOUT) {DsaBase::setIndirectRegisterSidx(sidx, timeout);}
|
|
|
void setConcatenatedMvt(int concat, long timeout = DEF_TIMEOUT) {DsaBase::setConcatenatedMvt(concat, timeout);}
|
|
|
void setProfileType(int sidx, int typ, long timeout = DEF_TIMEOUT) {DsaBase::setProfileType(sidx, typ, timeout);}
|
|
|
void setMvtLktNumber(int sidx, int number, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktNumber(sidx, number, timeout);}
|
|
|
void setMvtLktTime(int sidx, double time, long timeout = DEF_TIMEOUT) {DsaBase::setMvtLktTime(sidx, time, timeout);}
|
|
|
void setCameValue(double factor, long timeout = DEF_TIMEOUT) {DsaBase::setCameValue(factor, timeout);}
|
|
|
void setBrakeDeceleration(double dec, long timeout = DEF_TIMEOUT) {DsaBase::setBrakeDeceleration(dec, timeout);}
|
|
|
void setTargetPosition(int sidx, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTargetPosition(sidx, pos, timeout);}
|
|
|
void setProfileVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setProfileVelocity(sidx, vel, timeout);}
|
|
|
void setProfileAcceleration(int sidx, double acc, long timeout = DEF_TIMEOUT) {DsaBase::setProfileAcceleration(sidx, acc, timeout);}
|
|
|
void setJerkTime(int sidx, double tim, long timeout = DEF_TIMEOUT) {DsaBase::setJerkTime(sidx, tim, timeout);}
|
|
|
void setProfileDeceleration(int sidx, double dec, long timeout = DEF_TIMEOUT) {DsaBase::setProfileDeceleration(sidx, dec, timeout);}
|
|
|
void setEndVelocity(int sidx, double vel, long timeout = DEF_TIMEOUT) {DsaBase::setEndVelocity(sidx, vel, timeout);}
|
|
|
void setCtrlSourceType(int typ, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceType(typ, timeout);}
|
|
|
void setCtrlSourceIndex(int index, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlSourceIndex(index, timeout);}
|
|
|
void setCtrlShiftFactor(int shift, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlShiftFactor(shift, timeout);}
|
|
|
void setCtrlOffset(long offset, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlOffset(offset, timeout);}
|
|
|
void setCtrlGain(double gain, long timeout = DEF_TIMEOUT) {DsaBase::setCtrlGain(gain, timeout);}
|
|
|
void setMotorKTFactor(double kt, long timeout = DEF_TIMEOUT) {DsaBase::setMotorKTFactor(kt, timeout);}
|
|
|
|
|
|
void setPLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLProportionalGain(gain, handler, param);}
|
|
|
void setPLSpeedFeedbackGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedbackGain(gain, handler, param);}
|
|
|
void setPLForceFeedbackGain1(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain1(gain, handler, param);}
|
|
|
void setPLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorGain(gain, handler, param);}
|
|
|
void setPLAntiWindupGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setPLAntiWindupGain(gain, handler, param);}
|
|
|
void setPLIntegratorLimitation(double limit, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorLimitation(limit, handler, param);}
|
|
|
void setPLIntegratorMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setPLIntegratorMode(mode, handler, param);}
|
|
|
void setPLSpeedFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFilter(tim, handler, param);}
|
|
|
void setPLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPLOutputFilter(tim, handler, param);}
|
|
|
void setCLInputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLInputFilter(tim, handler, param);}
|
|
|
void setTtlSpecialFilter(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setTtlSpecialFilter(factor, handler, param);}
|
|
|
void setPLForceFeedbackGain2(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLForceFeedbackGain2(factor, handler, param);}
|
|
|
void setPLSpeedFeedfwdGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLSpeedFeedfwdGain(factor, handler, param);}
|
|
|
void setPLAccFeedforwardGain(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setPLAccFeedforwardGain(factor, handler, param);}
|
|
|
void setCLPhaseAdvanceFactor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceFactor(factor, handler, param);}
|
|
|
void setAprInputFilter(double time, DsaHandler handler, void *param = NULL) {DsaBase::setAprInputFilter(time, handler, param);}
|
|
|
void setCLPhaseAdvanceShift(double shift, DsaHandler handler, void *param = NULL) {DsaBase::setCLPhaseAdvanceShift(shift, handler, param);}
|
|
|
void setMinPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxPositionRangeLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxPositionRangeLimit(pos, handler, param);}
|
|
|
void setMaxProfileVelocity(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setMaxProfileVelocity(vel, handler, param);}
|
|
|
void setMaxAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setMaxAcceleration(acc, handler, param);}
|
|
|
void startMovement(double *targets, DsaHandler handler, void *param = NULL) {DsaBase::startMovement(targets, handler, param);}
|
|
|
|
|
|
void setFollowingErrorWindow(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setFollowingErrorWindow(pos, handler, param);}
|
|
|
void setVelocityErrorLimit(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setVelocityErrorLimit(vel, handler, param);}
|
|
|
void setSwitchLimitMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setSwitchLimitMode(mode, handler, param);}
|
|
|
void setEnableInputMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setEnableInputMode(mode, handler, param);}
|
|
|
void setMinSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMinSoftPositionLimit(pos, handler, param);}
|
|
|
void setMaxSoftPositionLimit(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setMaxSoftPositionLimit(pos, handler, param);}
|
|
|
void setProfileLimitMode(dword flags, DsaHandler handler, void *param = NULL) {DsaBase::setProfileLimitMode(flags, handler, param);}
|
|
|
void setIOErrorEventMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setIOErrorEventMask(mask, handler, param);}
|
|
|
void setPositionWindowTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindowTime(tim, handler, param);}
|
|
|
void setPositionWindow(double win, DsaHandler handler, void *param = NULL) {DsaBase::setPositionWindow(win, handler, param);}
|
|
|
void setHomingMethod(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingMethod(mode, handler, param);}
|
|
|
void setHomingZeroSpeed(double vel, DsaHandler handler, void *param = NULL) {DsaBase::setHomingZeroSpeed(vel, handler, param);}
|
|
|
void setHomingAcceleration(double acc, DsaHandler handler, void *param = NULL) {DsaBase::setHomingAcceleration(acc, handler, param);}
|
|
|
void setHomingFollowingLimit(double win, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFollowingLimit(win, handler, param);}
|
|
|
void setHomingCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setHomingCurrentLimit(cur, handler, param);}
|
|
|
void setHomeOffset(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomeOffset(pos, handler, param);}
|
|
|
void setHomingFixedMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFixedMvt(pos, handler, param);}
|
|
|
void setHomingSwitchMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingSwitchMvt(pos, handler, param);}
|
|
|
void setHomingIndexMvt(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setHomingIndexMvt(pos, handler, param);}
|
|
|
void setHomingFineTuningMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningMode(mode, handler, param);}
|
|
|
void setHomingFineTuningValue(double phase, DsaHandler handler, void *param = NULL) {DsaBase::setHomingFineTuningValue(phase, handler, param);}
|
|
|
void setMotorPhaseCorrection(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setMotorPhaseCorrection(mode, handler, param);}
|
|
|
void setSoftwareCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setSoftwareCurrentLimit(cur, handler, param);}
|
|
|
void setDriveControlMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDriveControlMode(mode, handler, param);}
|
|
|
void setDisplayMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setDisplayMode(mode, handler, param);}
|
|
|
void setEncoderInversion(double invert, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderInversion(invert, handler, param);}
|
|
|
void setPdrStepValue(double step, DsaHandler handler, void *param = NULL) {DsaBase::setPdrStepValue(step, handler, param);}
|
|
|
void setEncoderPhase1Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Offset(offset, handler, param);}
|
|
|
void setEncoderPhase2Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Offset(offset, handler, param);}
|
|
|
void setEncoderPhase1Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase1Factor(factor, handler, param);}
|
|
|
void setEncoderPhase2Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase2Factor(factor, handler, param);}
|
|
|
void setEncoderPhase3Offset(double offset, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Offset(offset, handler, param);}
|
|
|
void setEncoderIndexDistance(double pos, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderIndexDistance(pos, handler, param);}
|
|
|
void setEncoderPhase3Factor(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setEncoderPhase3Factor(factor, handler, param);}
|
|
|
void setCLProportionalGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLProportionalGain(gain, handler, param);}
|
|
|
void setCLIntegratorGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCLIntegratorGain(gain, handler, param);}
|
|
|
void setCLOutputFilter(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLOutputFilter(tim, handler, param);}
|
|
|
void setCLCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tCurrentLimit(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tCurrentLimit(cur, handler, param);}
|
|
|
void setCLI2tTimeLimit(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setCLI2tTimeLimit(tim, handler, param);}
|
|
|
void setCLRegenMode(int mode, DsaHandler handler, void *param = NULL) {DsaBase::setCLRegenMode(mode, handler, param);}
|
|
|
void setInitMode(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setInitMode(typ, handler, param);}
|
|
|
void setInitPulseLevel(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitPulseLevel(cur, handler, param);}
|
|
|
void setInitMaxCurrent(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitMaxCurrent(cur, handler, param);}
|
|
|
void setInitFinalPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitFinalPhase(cal, handler, param);}
|
|
|
void setInitTime(double tim, DsaHandler handler, void *param = NULL) {DsaBase::setInitTime(tim, handler, param);}
|
|
|
void setInitCurrentRate(double cur, DsaHandler handler, void *param = NULL) {DsaBase::setInitCurrentRate(cur, handler, param);}
|
|
|
void setInitPhaseRate(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitPhaseRate(cal, handler, param);}
|
|
|
void setInitInitialPhase(double cal, DsaHandler handler, void *param = NULL) {DsaBase::setInitInitialPhase(cal, handler, param);}
|
|
|
void setDriveFuseChecking(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setDriveFuseChecking(mask, handler, param);}
|
|
|
void setMotorTempChecking(dword val, DsaHandler handler, void *param = NULL) {DsaBase::setMotorTempChecking(val, handler, param);}
|
|
|
void setMonSourceType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceType(sidx, typ, handler, param);}
|
|
|
void setMonSourceIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonSourceIndex(sidx, index, handler, param);}
|
|
|
void setMonDestIndex(int sidx, int index, DsaHandler handler, void *param = NULL) {DsaBase::setMonDestIndex(sidx, index, handler, param);}
|
|
|
void setMonOffset(int sidx, long offset, DsaHandler handler, void *param = NULL) {DsaBase::setMonOffset(sidx, offset, handler, param);}
|
|
|
void setMonGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setMonGain(sidx, gain, handler, param);}
|
|
|
void setXAnalogOffset(int sidx, double offset, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOffset(sidx, offset, handler, param);}
|
|
|
void setXAnalogGain(int sidx, double gain, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogGain(sidx, gain, handler, param);}
|
|
|
void setSyncroInputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputMask(mask, handler, param);}
|
|
|
void setSyncroInputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroInputValue(mask, handler, param);}
|
|
|
void setSyncroOutputMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputMask(mask, handler, param);}
|
|
|
void setSyncroOutputValue(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroOutputValue(mask, handler, param);}
|
|
|
void setSyncroStartTimeout(int tim, DsaHandler handler, void *param = NULL) {DsaBase::setSyncroStartTimeout(tim, handler, param);}
|
|
|
void setDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setDigitalOutput(out, handler, param);}
|
|
|
void setXDigitalOutput(dword out, DsaHandler handler, void *param = NULL) {DsaBase::setXDigitalOutput(out, handler, param);}
|
|
|
void setXAnalogOutput1(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput1(out, handler, param);}
|
|
|
void setXAnalogOutput2(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput2(out, handler, param);}
|
|
|
void setXAnalogOutput3(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput3(out, handler, param);}
|
|
|
void setXAnalogOutput4(double out, DsaHandler handler, void *param = NULL) {DsaBase::setXAnalogOutput4(out, handler, param);}
|
|
|
void setAnalogOutput(double out, DsaHandler handler, void *param = NULL) {DsaBase::setAnalogOutput(out, handler, param);}
|
|
|
void setInterruptMask1(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask1(sidx, mask, handler, param);}
|
|
|
void setInterruptMask2(int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setInterruptMask2(sidx, mask, handler, param);}
|
|
|
void setTriggerIrqMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIrqMask(mask, handler, param);}
|
|
|
void setTriggerIOMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerIOMask(mask, handler, param);}
|
|
|
void setTriggerMapOffset(int offset, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapOffset(offset, handler, param);}
|
|
|
void setTriggerMapSize(int size, DsaHandler handler, void *param = NULL) {DsaBase::setTriggerMapSize(size, handler, param);}
|
|
|
void setRealtimeEnabledGlobal(int enable, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledGlobal(enable, handler, param);}
|
|
|
void setRealtimeValidMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeValidMask(mask, handler, param);}
|
|
|
void setRealtimeEnabledMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimeEnabledMask(mask, handler, param);}
|
|
|
void setRealtimePendingMask(dword mask, DsaHandler handler, void *param = NULL) {DsaBase::setRealtimePendingMask(mask, handler, param);}
|
|
|
void setEblBaudrate(long baud, DsaHandler handler, void *param = NULL) {DsaBase::setEblBaudrate(baud, handler, param);}
|
|
|
void setIndirectAxisNumber(int axis, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectAxisNumber(axis, handler, param);}
|
|
|
void setIndirectRegisterIdx(int idx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterIdx(idx, handler, param);}
|
|
|
void setIndirectRegisterSidx(int sidx, DsaHandler handler, void *param = NULL) {DsaBase::setIndirectRegisterSidx(sidx, handler, param);}
|
|
|
void setConcatenatedMvt(int concat, DsaHandler handler, void *param = NULL) {DsaBase::setConcatenatedMvt(concat, handler, param);}
|
|
|
void setProfileType(int sidx, int typ, DsaHandler handler, void *param = NULL) {DsaBase::setProfileType(sidx, typ, handler, param);}
|
|
|
void setMvtLktNumber(int sidx, int number, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktNumber(sidx, number, handler, param);}
|
|
|
void setMvtLktTime(int sidx, double time, DsaHandler handler, void *param = NULL) {DsaBase::setMvtLktTime(sidx, time, handler, param);}
|
|
|
void setCameValue(double factor, DsaHandler handler, void *param = NULL) {DsaBase::setCameValue(factor, handler, param);}
|
|
|
void setBrakeDeceleration(double dec, DsaHandler handler, void *param = NULL) {DsaBase::setBrakeDeceleration(dec, handler, param);}
|
|
|
void setTargetPosition(int sidx, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTargetPosition(sidx, pos, handler, param);}
|
|
|
void setProfileVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setProfileVelocity(sidx, vel, handler, param);}
|
|
|
void setProfileAcceleration(int sidx, double acc, DsaHandler handler, void *param = NULL) {DsaBase::setProfileAcceleration(sidx, acc, handler, param);}
|
|
|
void setJerkTime(int sidx, double tim, DsaHandler handler, void *param = NULL) {DsaBase::setJerkTime(sidx, tim, handler, param);}
|
|
|
void setProfileDeceleration(int sidx, double dec, DsaHandler handler, void *param = NULL) {DsaBase::setProfileDeceleration(sidx, dec, handler, param);}
|
|
|
void setEndVelocity(int sidx, double vel, DsaHandler handler, void *param = NULL) {DsaBase::setEndVelocity(sidx, vel, handler, param);}
|
|
|
void setCtrlSourceType(int typ, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceType(typ, handler, param);}
|
|
|
void setCtrlSourceIndex(int index, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlSourceIndex(index, handler, param);}
|
|
|
void setCtrlShiftFactor(int shift, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlShiftFactor(shift, handler, param);}
|
|
|
void setCtrlOffset(long offset, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlOffset(offset, handler, param);}
|
|
|
void setCtrlGain(double gain, DsaHandler handler, void *param = NULL) {DsaBase::setCtrlGain(gain, handler, param);}
|
|
|
void setMotorKTFactor(double kt, DsaHandler handler, void *param = NULL) {DsaBase::setMotorKTFactor(kt, handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaGPModuleBase class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaGPModuleBase: public DsaBase {
|
|
|
/* constructors */
|
|
|
protected:
|
|
|
DsaGPModuleBase(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaGPModuleBase(DsaGPModuleBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaGPModuleBase(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_gp_module_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaGPModuleBase operator = (DsaGPModuleBase &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaGPModuleBase operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_gp_module_base(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaGPModule class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaGPModule: public DsaBase {
|
|
|
/* constructors */
|
|
|
public:
|
|
|
DsaGPModule(void) {
|
|
|
dsa = NULL;
|
|
|
ERRCHK(dsa_create_gp_module(&dsa));
|
|
|
}
|
|
|
DsaGPModule(DsaGPModule &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaGPModule(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_gp_module(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
public:
|
|
|
/* operators */
|
|
|
DsaGPModule operator = (DsaGPModule &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaGPModule operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_gp_module(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
int getWarningCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getWarningCode(kind, timeout);}
|
|
|
int getErrorCode(int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getErrorCode(kind, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
long getRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegister(typ, idx, sidx, kind, timeout);}
|
|
|
long getRegisterInt32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt32(typ, idx, sidx, kind, timeout);}
|
|
|
eint64 getRegisterInt64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterInt64(typ, idx, sidx, kind, timeout);}
|
|
|
float getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat32(typ, idx, sidx, kind, timeout);}
|
|
|
double getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getRegisterFloat64(typ, idx, sidx, kind, timeout);}
|
|
|
float getFloatRegister(int typ, unsigned idx, int sidx, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getFloatRegister(typ, idx, sidx, kind, timeout);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayInt64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat32(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void getArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getArrayFloat64(typ, idx, nidx, sidx, val, offset, kind, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
double getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, long timeout = DEF_TIMEOUT) {return DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, timeout);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, long timeout = DEF_TIMEOUT) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, long timeout = DEF_TIMEOUT) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, timeout);}
|
|
|
DsaStatus waitStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
DsaStatus waitStatusChange(DsaStatus *mask, long timeout = DEF_TIMEOUT) {return DsaBase::waitStatusChange(mask, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void getWarningCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getWarningCode(kind, handler, param);}
|
|
|
void getErrorCode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getErrorCode(kind, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void getRegister(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt32(int typ, unsigned idx, int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getRegisterInt32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterInt64(int typ, unsigned idx, int sidx, int kind, DsaInt64Handler handler, void *param = NULL) {DsaBase::getRegisterInt64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat32(int typ, unsigned idx, int sidx, int kind, DsaFloatHandler handler, void *param = NULL) {DsaBase::getRegisterFloat32(typ, idx, sidx, kind, handler, param);}
|
|
|
void getRegisterFloat64(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRegisterFloat64(typ, idx, sidx, kind, handler, param);}
|
|
|
void getFloatRegister(int typ, unsigned idx, int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFloatRegister(typ, idx, sidx, kind, handler, param);}
|
|
|
void getArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getArray(typ, idx, nidx, sidx, val, offset, kind, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void getIsoRegister(int typ, unsigned idx, int sidx, int conv, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getIsoRegister(typ, idx, sidx, conv, kind, handler, param);}
|
|
|
void getIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, int kind, DsaHandler handler, void *param = NULL) {DsaBase::getIsoArray(typ, idx, nidx, sidx, val, offset, conv, kind, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void quickRegisterRequest(int typ1, unsigned idx1, int sidx1, long *val1, int typ2, unsigned idx2, int sidx2, long *val2, dword *rx_time, Dsa2intHandler handler, void *param = NULL) {DsaBase::quickRegisterRequest(typ1, idx1, sidx1, val1, typ2, idx2, sidx2, val2, rx_time, handler, param);}
|
|
|
void waitStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusEqual(mask, ref, handler, param);}
|
|
|
void waitStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void waitStatusChange(DsaStatus *mask, DsaStatusHandler handler, void *param = NULL) {DsaBase::waitStatusChange(mask, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void open(EtbBus etb, int axis) {DsaBase::open(etb, axis);}
|
|
|
void etcomOpen(EtbBus etb, int axis) {DsaBase::etcomOpen(etb, axis);}
|
|
|
void open(char_cp url) {DsaBase::open(url);}
|
|
|
void open(EtbBus etb, int axis, dword flags) {DsaBase::open(etb, axis, flags);}
|
|
|
void etcomOpen(EtbBus etb, int axis, dword flags) {DsaBase::etcomOpen(etb, axis, flags);}
|
|
|
void reset() {DsaBase::reset();}
|
|
|
void close() {DsaBase::close();}
|
|
|
EtbBus getEtbBus() {return DsaBase::getEtbBus();}
|
|
|
int getEtbAxis() {return DsaBase::getEtbAxis();}
|
|
|
int etcomGetEtbAxis() {return DsaBase::etcomGetEtbAxis();}
|
|
|
bool isOpen() {return DsaBase::isOpen();}
|
|
|
int getMotorTyp() {return DsaBase::getMotorTyp();}
|
|
|
void getErrorText(char_p text, int size, int code) {DsaBase::getErrorText(text, size, code);}
|
|
|
void getWarningText(char_p text, int size, int code) {DsaBase::getWarningText(text, size, code);}
|
|
|
double convertToIso(long inc, int conv) {return DsaBase::convertToIso(inc, conv);}
|
|
|
double convertInt32ToIso(long inc, int conv) {return DsaBase::convertInt32ToIso(inc, conv);}
|
|
|
double convertInt64ToIso(eint64 inc, int conv) {return DsaBase::convertInt64ToIso(inc, conv);}
|
|
|
double convertFloat32ToIso(float inc, int conv) {return DsaBase::convertFloat32ToIso(inc, conv);}
|
|
|
double convertFloat64ToIso(double inc, int conv) {return DsaBase::convertFloat64ToIso(inc, conv);}
|
|
|
long convertFromIso(double iso, int conv) {return DsaBase::convertFromIso(iso, conv);}
|
|
|
long convertInt32FromIso(double iso, int conv) {return DsaBase::convertInt32FromIso(iso, conv);}
|
|
|
eint64 convertInt64FromIso(double iso, int conv) {return DsaBase::convertInt64FromIso(iso, conv);}
|
|
|
float convertFloat32FromIso(double iso, int conv) {return DsaBase::convertFloat32FromIso(iso, conv);}
|
|
|
double convertFloat64FromIso(double iso, int conv) {return DsaBase::convertFloat64FromIso(iso, conv);}
|
|
|
double getIncToIsoFactor(int conv) {return DsaBase::getIncToIsoFactor(conv);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
DsaInfo getInfo() {return DsaBase::getInfo();}
|
|
|
DsaStatus getStatus() {return DsaBase::getStatus();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
DsaStatus getStatusFromDrive(long timeout = DEF_TIMEOUT) {return DsaBase::getStatusFromDrive(timeout);}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
double queryMinimumSampleTime() {return DsaBase::queryMinimumSampleTime();}
|
|
|
double querySampleTime(double time) {return DsaBase::querySampleTime(time);}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
DsaXInfo getXInfo() {return DsaBase::getXInfo();}
|
|
|
DmdData getDmdData() {return DsaBase::getDmdData();}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
|
|
|
/* register setters */
|
|
|
|
|
|
|
|
|
/* register getters */
|
|
|
double getPLProportionalGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLProportionalGain(kind, timeout);}
|
|
|
void getPLProportionalGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLProportionalGain(gain, kind, timeout);}
|
|
|
double getPLSpeedFeedbackGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLSpeedFeedbackGain(kind, timeout);}
|
|
|
void getPLSpeedFeedbackGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLSpeedFeedbackGain(gain, kind, timeout);}
|
|
|
double getPLForceFeedbackGain1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLForceFeedbackGain1(kind, timeout);}
|
|
|
void getPLForceFeedbackGain1(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLForceFeedbackGain1(gain, kind, timeout);}
|
|
|
double getPLIntegratorGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLIntegratorGain(kind, timeout);}
|
|
|
void getPLIntegratorGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLIntegratorGain(gain, kind, timeout);}
|
|
|
double getPLAntiWindupGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLAntiWindupGain(kind, timeout);}
|
|
|
void getPLAntiWindupGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLAntiWindupGain(gain, kind, timeout);}
|
|
|
double getPLIntegratorLimitation(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLIntegratorLimitation(kind, timeout);}
|
|
|
void getPLIntegratorLimitation(double *limit, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLIntegratorLimitation(limit, kind, timeout);}
|
|
|
int getPLIntegratorMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLIntegratorMode(kind, timeout);}
|
|
|
void getPLIntegratorMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLIntegratorMode(mode, kind, timeout);}
|
|
|
double getPLSpeedFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLSpeedFilter(kind, timeout);}
|
|
|
void getPLSpeedFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLSpeedFilter(tim, kind, timeout);}
|
|
|
double getPLOutputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLOutputFilter(kind, timeout);}
|
|
|
void getPLOutputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLOutputFilter(tim, kind, timeout);}
|
|
|
double getCLInputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLInputFilter(kind, timeout);}
|
|
|
void getCLInputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLInputFilter(tim, kind, timeout);}
|
|
|
double getTtlSpecialFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTtlSpecialFilter(kind, timeout);}
|
|
|
void getTtlSpecialFilter(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTtlSpecialFilter(factor, kind, timeout);}
|
|
|
double getPLForceFeedbackGain2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLForceFeedbackGain2(kind, timeout);}
|
|
|
void getPLForceFeedbackGain2(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLForceFeedbackGain2(factor, kind, timeout);}
|
|
|
double getPLSpeedFeedfwdGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLSpeedFeedfwdGain(kind, timeout);}
|
|
|
void getPLSpeedFeedfwdGain(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLSpeedFeedfwdGain(factor, kind, timeout);}
|
|
|
double getPLAccFeedforwardGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPLAccFeedforwardGain(kind, timeout);}
|
|
|
void getPLAccFeedforwardGain(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPLAccFeedforwardGain(factor, kind, timeout);}
|
|
|
double getCLPhaseAdvanceFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLPhaseAdvanceFactor(kind, timeout);}
|
|
|
void getCLPhaseAdvanceFactor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLPhaseAdvanceFactor(factor, kind, timeout);}
|
|
|
double getAprInputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAprInputFilter(kind, timeout);}
|
|
|
void getAprInputFilter(double *time, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAprInputFilter(time, kind, timeout);}
|
|
|
double getCLPhaseAdvanceShift(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLPhaseAdvanceShift(kind, timeout);}
|
|
|
void getCLPhaseAdvanceShift(double *shift, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLPhaseAdvanceShift(shift, kind, timeout);}
|
|
|
double getMinPositionRangeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMinPositionRangeLimit(kind, timeout);}
|
|
|
void getMinPositionRangeLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMinPositionRangeLimit(pos, kind, timeout);}
|
|
|
double getMaxPositionRangeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxPositionRangeLimit(kind, timeout);}
|
|
|
void getMaxPositionRangeLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxPositionRangeLimit(pos, kind, timeout);}
|
|
|
double getMaxProfileVelocity(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxProfileVelocity(kind, timeout);}
|
|
|
void getMaxProfileVelocity(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxProfileVelocity(vel, kind, timeout);}
|
|
|
double getMaxAcceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxAcceleration(kind, timeout);}
|
|
|
void getMaxAcceleration(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxAcceleration(acc, kind, timeout);}
|
|
|
double getFollowingErrorWindow(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getFollowingErrorWindow(kind, timeout);}
|
|
|
void getFollowingErrorWindow(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getFollowingErrorWindow(pos, kind, timeout);}
|
|
|
double getVelocityErrorLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getVelocityErrorLimit(kind, timeout);}
|
|
|
void getVelocityErrorLimit(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getVelocityErrorLimit(vel, kind, timeout);}
|
|
|
int getSwitchLimitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSwitchLimitMode(kind, timeout);}
|
|
|
void getSwitchLimitMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSwitchLimitMode(mode, kind, timeout);}
|
|
|
int getEnableInputMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEnableInputMode(kind, timeout);}
|
|
|
void getEnableInputMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEnableInputMode(mode, kind, timeout);}
|
|
|
double getMinSoftPositionLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMinSoftPositionLimit(kind, timeout);}
|
|
|
void getMinSoftPositionLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMinSoftPositionLimit(pos, kind, timeout);}
|
|
|
double getMaxSoftPositionLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMaxSoftPositionLimit(kind, timeout);}
|
|
|
void getMaxSoftPositionLimit(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMaxSoftPositionLimit(pos, kind, timeout);}
|
|
|
dword getProfileLimitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileLimitMode(kind, timeout);}
|
|
|
void getProfileLimitMode(dword *flags, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileLimitMode(flags, kind, timeout);}
|
|
|
dword getIOErrorEventMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIOErrorEventMask(kind, timeout);}
|
|
|
void getIOErrorEventMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIOErrorEventMask(mask, kind, timeout);}
|
|
|
double getPositionWindowTime(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionWindowTime(kind, timeout);}
|
|
|
void getPositionWindowTime(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionWindowTime(tim, kind, timeout);}
|
|
|
double getPositionWindow(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionWindow(kind, timeout);}
|
|
|
void getPositionWindow(double *win, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionWindow(win, kind, timeout);}
|
|
|
int getHomingMethod(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingMethod(kind, timeout);}
|
|
|
void getHomingMethod(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingMethod(mode, kind, timeout);}
|
|
|
double getHomingZeroSpeed(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingZeroSpeed(kind, timeout);}
|
|
|
void getHomingZeroSpeed(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingZeroSpeed(vel, kind, timeout);}
|
|
|
double getHomingAcceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingAcceleration(kind, timeout);}
|
|
|
void getHomingAcceleration(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingAcceleration(acc, kind, timeout);}
|
|
|
double getHomingFollowingLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFollowingLimit(kind, timeout);}
|
|
|
void getHomingFollowingLimit(double *win, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFollowingLimit(win, kind, timeout);}
|
|
|
double getHomingCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingCurrentLimit(kind, timeout);}
|
|
|
void getHomingCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingCurrentLimit(cur, kind, timeout);}
|
|
|
double getHomeOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomeOffset(kind, timeout);}
|
|
|
void getHomeOffset(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomeOffset(pos, kind, timeout);}
|
|
|
double getHomingFixedMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFixedMvt(kind, timeout);}
|
|
|
void getHomingFixedMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFixedMvt(pos, kind, timeout);}
|
|
|
double getHomingSwitchMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingSwitchMvt(kind, timeout);}
|
|
|
void getHomingSwitchMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingSwitchMvt(pos, kind, timeout);}
|
|
|
double getHomingIndexMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingIndexMvt(kind, timeout);}
|
|
|
void getHomingIndexMvt(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingIndexMvt(pos, kind, timeout);}
|
|
|
int getHomingFineTuningMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFineTuningMode(kind, timeout);}
|
|
|
void getHomingFineTuningMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFineTuningMode(mode, kind, timeout);}
|
|
|
double getHomingFineTuningValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getHomingFineTuningValue(kind, timeout);}
|
|
|
void getHomingFineTuningValue(double *phase, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getHomingFineTuningValue(phase, kind, timeout);}
|
|
|
int getMotorPhaseCorrection(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMotorPhaseCorrection(kind, timeout);}
|
|
|
void getMotorPhaseCorrection(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMotorPhaseCorrection(mode, kind, timeout);}
|
|
|
double getSoftwareCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSoftwareCurrentLimit(kind, timeout);}
|
|
|
void getSoftwareCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSoftwareCurrentLimit(cur, kind, timeout);}
|
|
|
int getDriveControlMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveControlMode(kind, timeout);}
|
|
|
void getDriveControlMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveControlMode(mode, kind, timeout);}
|
|
|
int getDisplayMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDisplayMode(kind, timeout);}
|
|
|
void getDisplayMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDisplayMode(mode, kind, timeout);}
|
|
|
double getEncoderInversion(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderInversion(kind, timeout);}
|
|
|
void getEncoderInversion(double *invert, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderInversion(invert, kind, timeout);}
|
|
|
double getPdrStepValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPdrStepValue(kind, timeout);}
|
|
|
void getPdrStepValue(double *step, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPdrStepValue(step, kind, timeout);}
|
|
|
double getEncoderPhase1Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase1Offset(kind, timeout);}
|
|
|
void getEncoderPhase1Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase1Offset(offset, kind, timeout);}
|
|
|
double getEncoderPhase2Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase2Offset(kind, timeout);}
|
|
|
void getEncoderPhase2Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase2Offset(offset, kind, timeout);}
|
|
|
double getEncoderPhase1Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase1Factor(kind, timeout);}
|
|
|
void getEncoderPhase1Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase1Factor(factor, kind, timeout);}
|
|
|
double getEncoderPhase2Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase2Factor(kind, timeout);}
|
|
|
void getEncoderPhase2Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase2Factor(factor, kind, timeout);}
|
|
|
double getEncoderPhase3Offset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase3Offset(kind, timeout);}
|
|
|
void getEncoderPhase3Offset(double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase3Offset(offset, kind, timeout);}
|
|
|
double getEncoderIndexDistance(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderIndexDistance(kind, timeout);}
|
|
|
void getEncoderIndexDistance(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderIndexDistance(pos, kind, timeout);}
|
|
|
double getEncoderPhase3Factor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderPhase3Factor(kind, timeout);}
|
|
|
void getEncoderPhase3Factor(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderPhase3Factor(factor, kind, timeout);}
|
|
|
double getCLProportionalGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLProportionalGain(kind, timeout);}
|
|
|
void getCLProportionalGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLProportionalGain(gain, kind, timeout);}
|
|
|
double getCLIntegratorGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLIntegratorGain(kind, timeout);}
|
|
|
void getCLIntegratorGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLIntegratorGain(gain, kind, timeout);}
|
|
|
double getCLOutputFilter(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLOutputFilter(kind, timeout);}
|
|
|
void getCLOutputFilter(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLOutputFilter(tim, kind, timeout);}
|
|
|
double getCLCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentLimit(kind, timeout);}
|
|
|
void getCLCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentLimit(cur, kind, timeout);}
|
|
|
double getCLI2tCurrentLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLI2tCurrentLimit(kind, timeout);}
|
|
|
void getCLI2tCurrentLimit(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLI2tCurrentLimit(cur, kind, timeout);}
|
|
|
double getCLI2tTimeLimit(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLI2tTimeLimit(kind, timeout);}
|
|
|
void getCLI2tTimeLimit(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLI2tTimeLimit(tim, kind, timeout);}
|
|
|
int getCLRegenMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLRegenMode(kind, timeout);}
|
|
|
void getCLRegenMode(int *mode, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLRegenMode(mode, kind, timeout);}
|
|
|
int getInitMode(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitMode(kind, timeout);}
|
|
|
void getInitMode(int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitMode(typ, kind, timeout);}
|
|
|
double getInitPulseLevel(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitPulseLevel(kind, timeout);}
|
|
|
void getInitPulseLevel(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitPulseLevel(cur, kind, timeout);}
|
|
|
double getInitMaxCurrent(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitMaxCurrent(kind, timeout);}
|
|
|
void getInitMaxCurrent(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitMaxCurrent(cur, kind, timeout);}
|
|
|
double getInitFinalPhase(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitFinalPhase(kind, timeout);}
|
|
|
void getInitFinalPhase(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitFinalPhase(cal, kind, timeout);}
|
|
|
double getInitTime(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitTime(kind, timeout);}
|
|
|
void getInitTime(double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitTime(tim, kind, timeout);}
|
|
|
double getInitCurrentRate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitCurrentRate(kind, timeout);}
|
|
|
void getInitCurrentRate(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitCurrentRate(cur, kind, timeout);}
|
|
|
double getInitPhaseRate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitPhaseRate(kind, timeout);}
|
|
|
void getInitPhaseRate(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitPhaseRate(cal, kind, timeout);}
|
|
|
double getInitInitialPhase(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInitInitialPhase(kind, timeout);}
|
|
|
void getInitInitialPhase(double *cal, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInitInitialPhase(cal, kind, timeout);}
|
|
|
dword getDriveFuseChecking(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveFuseChecking(kind, timeout);}
|
|
|
void getDriveFuseChecking(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveFuseChecking(mask, kind, timeout);}
|
|
|
dword getMotorTempChecking(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMotorTempChecking(kind, timeout);}
|
|
|
void getMotorTempChecking(dword *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMotorTempChecking(val, kind, timeout);}
|
|
|
int getMonSourceType(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonSourceType(sidx, kind, timeout);}
|
|
|
void getMonSourceType(int sidx, int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonSourceType(sidx, typ, kind, timeout);}
|
|
|
int getMonSourceIndex(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonSourceIndex(sidx, kind, timeout);}
|
|
|
void getMonSourceIndex(int sidx, int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonSourceIndex(sidx, index, kind, timeout);}
|
|
|
int getMonDestIndex(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonDestIndex(sidx, kind, timeout);}
|
|
|
void getMonDestIndex(int sidx, int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonDestIndex(sidx, index, kind, timeout);}
|
|
|
long getMonOffset(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonOffset(sidx, kind, timeout);}
|
|
|
void getMonOffset(int sidx, long *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonOffset(sidx, offset, kind, timeout);}
|
|
|
double getMonGain(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMonGain(sidx, kind, timeout);}
|
|
|
void getMonGain(int sidx, double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMonGain(sidx, gain, kind, timeout);}
|
|
|
double getXAnalogOffset(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOffset(sidx, kind, timeout);}
|
|
|
void getXAnalogOffset(int sidx, double *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOffset(sidx, offset, kind, timeout);}
|
|
|
double getXAnalogGain(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogGain(sidx, kind, timeout);}
|
|
|
void getXAnalogGain(int sidx, double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogGain(sidx, gain, kind, timeout);}
|
|
|
dword getSyncroInputMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroInputMask(kind, timeout);}
|
|
|
void getSyncroInputMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroInputMask(mask, kind, timeout);}
|
|
|
dword getSyncroInputValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroInputValue(kind, timeout);}
|
|
|
void getSyncroInputValue(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroInputValue(mask, kind, timeout);}
|
|
|
dword getSyncroOutputMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroOutputMask(kind, timeout);}
|
|
|
void getSyncroOutputMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroOutputMask(mask, kind, timeout);}
|
|
|
dword getSyncroOutputValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroOutputValue(kind, timeout);}
|
|
|
void getSyncroOutputValue(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroOutputValue(mask, kind, timeout);}
|
|
|
int getSyncroStartTimeout(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getSyncroStartTimeout(kind, timeout);}
|
|
|
void getSyncroStartTimeout(int *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getSyncroStartTimeout(tim, kind, timeout);}
|
|
|
dword getDigitalOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDigitalOutput(kind, timeout);}
|
|
|
void getDigitalOutput(dword *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDigitalOutput(out, kind, timeout);}
|
|
|
dword getXDigitalOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXDigitalOutput(kind, timeout);}
|
|
|
void getXDigitalOutput(dword *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXDigitalOutput(out, kind, timeout);}
|
|
|
double getXAnalogOutput1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput1(kind, timeout);}
|
|
|
void getXAnalogOutput1(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput1(out, kind, timeout);}
|
|
|
double getXAnalogOutput2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput2(kind, timeout);}
|
|
|
void getXAnalogOutput2(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput2(out, kind, timeout);}
|
|
|
double getXAnalogOutput3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput3(kind, timeout);}
|
|
|
void getXAnalogOutput3(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput3(out, kind, timeout);}
|
|
|
double getXAnalogOutput4(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogOutput4(kind, timeout);}
|
|
|
void getXAnalogOutput4(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogOutput4(out, kind, timeout);}
|
|
|
double getAnalogOutput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAnalogOutput(kind, timeout);}
|
|
|
void getAnalogOutput(double *out, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAnalogOutput(out, kind, timeout);}
|
|
|
dword getInterruptMask1(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInterruptMask1(sidx, kind, timeout);}
|
|
|
void getInterruptMask1(int sidx, dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInterruptMask1(sidx, mask, kind, timeout);}
|
|
|
dword getInterruptMask2(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getInterruptMask2(sidx, kind, timeout);}
|
|
|
void getInterruptMask2(int sidx, dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getInterruptMask2(sidx, mask, kind, timeout);}
|
|
|
dword getTriggerIrqMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerIrqMask(kind, timeout);}
|
|
|
void getTriggerIrqMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerIrqMask(mask, kind, timeout);}
|
|
|
dword getTriggerIOMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerIOMask(kind, timeout);}
|
|
|
void getTriggerIOMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerIOMask(mask, kind, timeout);}
|
|
|
int getTriggerMapOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerMapOffset(kind, timeout);}
|
|
|
void getTriggerMapOffset(int *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerMapOffset(offset, kind, timeout);}
|
|
|
int getTriggerMapSize(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTriggerMapSize(kind, timeout);}
|
|
|
void getTriggerMapSize(int *size, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTriggerMapSize(size, kind, timeout);}
|
|
|
int getRealtimeEnabledGlobal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimeEnabledGlobal(kind, timeout);}
|
|
|
void getRealtimeEnabledGlobal(int *enable, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimeEnabledGlobal(enable, kind, timeout);}
|
|
|
dword getRealtimeValidMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimeValidMask(kind, timeout);}
|
|
|
void getRealtimeValidMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimeValidMask(mask, kind, timeout);}
|
|
|
dword getRealtimeEnabledMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimeEnabledMask(kind, timeout);}
|
|
|
void getRealtimeEnabledMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimeEnabledMask(mask, kind, timeout);}
|
|
|
dword getRealtimePendingMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRealtimePendingMask(kind, timeout);}
|
|
|
void getRealtimePendingMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRealtimePendingMask(mask, kind, timeout);}
|
|
|
long getEblBaudrate(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEblBaudrate(kind, timeout);}
|
|
|
void getEblBaudrate(long *baud, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEblBaudrate(baud, kind, timeout);}
|
|
|
int getIndirectAxisNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIndirectAxisNumber(kind, timeout);}
|
|
|
void getIndirectAxisNumber(int *axis, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIndirectAxisNumber(axis, kind, timeout);}
|
|
|
int getIndirectRegisterIdx(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIndirectRegisterIdx(kind, timeout);}
|
|
|
void getIndirectRegisterIdx(int *idx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIndirectRegisterIdx(idx, kind, timeout);}
|
|
|
int getIndirectRegisterSidx(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIndirectRegisterSidx(kind, timeout);}
|
|
|
void getIndirectRegisterSidx(int *sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIndirectRegisterSidx(sidx, kind, timeout);}
|
|
|
int getConcatenatedMvt(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getConcatenatedMvt(kind, timeout);}
|
|
|
void getConcatenatedMvt(int *concat, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getConcatenatedMvt(concat, kind, timeout);}
|
|
|
int getProfileType(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileType(sidx, kind, timeout);}
|
|
|
void getProfileType(int sidx, int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileType(sidx, typ, kind, timeout);}
|
|
|
int getMvtLktNumber(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMvtLktNumber(sidx, kind, timeout);}
|
|
|
void getMvtLktNumber(int sidx, int *number, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMvtLktNumber(sidx, number, kind, timeout);}
|
|
|
double getMvtLktTime(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMvtLktTime(sidx, kind, timeout);}
|
|
|
void getMvtLktTime(int sidx, double *time, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMvtLktTime(sidx, time, kind, timeout);}
|
|
|
double getCameValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCameValue(kind, timeout);}
|
|
|
void getCameValue(double *factor, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCameValue(factor, kind, timeout);}
|
|
|
double getBrakeDeceleration(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getBrakeDeceleration(kind, timeout);}
|
|
|
void getBrakeDeceleration(double *dec, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getBrakeDeceleration(dec, kind, timeout);}
|
|
|
double getTargetPosition(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getTargetPosition(sidx, kind, timeout);}
|
|
|
void getTargetPosition(int sidx, double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getTargetPosition(sidx, pos, kind, timeout);}
|
|
|
double getProfileVelocity(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileVelocity(sidx, kind, timeout);}
|
|
|
void getProfileVelocity(int sidx, double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileVelocity(sidx, vel, kind, timeout);}
|
|
|
double getProfileAcceleration(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileAcceleration(sidx, kind, timeout);}
|
|
|
void getProfileAcceleration(int sidx, double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileAcceleration(sidx, acc, kind, timeout);}
|
|
|
double getJerkTime(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getJerkTime(sidx, kind, timeout);}
|
|
|
void getJerkTime(int sidx, double *tim, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getJerkTime(sidx, tim, kind, timeout);}
|
|
|
double getProfileDeceleration(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getProfileDeceleration(sidx, kind, timeout);}
|
|
|
void getProfileDeceleration(int sidx, double *dec, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getProfileDeceleration(sidx, dec, kind, timeout);}
|
|
|
double getEndVelocity(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEndVelocity(sidx, kind, timeout);}
|
|
|
void getEndVelocity(int sidx, double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEndVelocity(sidx, vel, kind, timeout);}
|
|
|
int getCtrlSourceType(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlSourceType(kind, timeout);}
|
|
|
void getCtrlSourceType(int *typ, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlSourceType(typ, kind, timeout);}
|
|
|
int getCtrlSourceIndex(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlSourceIndex(kind, timeout);}
|
|
|
void getCtrlSourceIndex(int *index, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlSourceIndex(index, kind, timeout);}
|
|
|
int getCtrlShiftFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlShiftFactor(kind, timeout);}
|
|
|
void getCtrlShiftFactor(int *shift, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlShiftFactor(shift, kind, timeout);}
|
|
|
long getCtrlOffset(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlOffset(kind, timeout);}
|
|
|
void getCtrlOffset(long *offset, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlOffset(offset, kind, timeout);}
|
|
|
double getCtrlGain(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCtrlGain(kind, timeout);}
|
|
|
void getCtrlGain(double *gain, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCtrlGain(gain, kind, timeout);}
|
|
|
double getMotorKTFactor(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getMotorKTFactor(kind, timeout);}
|
|
|
void getMotorKTFactor(double *kt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getMotorKTFactor(kt, kind, timeout);}
|
|
|
double getPositionCtrlError(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionCtrlError(kind, timeout);}
|
|
|
void getPositionCtrlError(double *err, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionCtrlError(err, kind, timeout);}
|
|
|
double getPositionMaxError(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionMaxError(kind, timeout);}
|
|
|
void getPositionMaxError(double *err, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionMaxError(err, kind, timeout);}
|
|
|
double getPositionDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionDemandValue(kind, timeout);}
|
|
|
void getPositionDemandValue(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionDemandValue(pos, kind, timeout);}
|
|
|
double getPositionActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getPositionActualValue(kind, timeout);}
|
|
|
void getPositionActualValue(double *pos, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getPositionActualValue(pos, kind, timeout);}
|
|
|
double getVelocityDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getVelocityDemandValue(kind, timeout);}
|
|
|
void getVelocityDemandValue(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getVelocityDemandValue(vel, kind, timeout);}
|
|
|
double getVelocityActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getVelocityActualValue(kind, timeout);}
|
|
|
void getVelocityActualValue(double *vel, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getVelocityActualValue(vel, kind, timeout);}
|
|
|
double getAccDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAccDemandValue(kind, timeout);}
|
|
|
void getAccDemandValue(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAccDemandValue(acc, kind, timeout);}
|
|
|
double getAccActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAccActualValue(kind, timeout);}
|
|
|
void getAccActualValue(double *acc, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAccActualValue(acc, kind, timeout);}
|
|
|
double getRefDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getRefDemandValue(kind, timeout);}
|
|
|
void getRefDemandValue(double *ref, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getRefDemandValue(ref, kind, timeout);}
|
|
|
dword getDriveControlMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveControlMask(kind, timeout);}
|
|
|
void getDriveControlMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveControlMask(mask, kind, timeout);}
|
|
|
double getCLCurrentPhase1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentPhase1(kind, timeout);}
|
|
|
void getCLCurrentPhase1(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentPhase1(cur, kind, timeout);}
|
|
|
double getCLCurrentPhase2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentPhase2(kind, timeout);}
|
|
|
void getCLCurrentPhase2(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentPhase2(cur, kind, timeout);}
|
|
|
double getCLCurrentPhase3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLCurrentPhase3(kind, timeout);}
|
|
|
void getCLCurrentPhase3(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLCurrentPhase3(cur, kind, timeout);}
|
|
|
double getCLLktPhase1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLLktPhase1(kind, timeout);}
|
|
|
void getCLLktPhase1(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLLktPhase1(lkt, kind, timeout);}
|
|
|
double getCLLktPhase2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLLktPhase2(kind, timeout);}
|
|
|
void getCLLktPhase2(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLLktPhase2(lkt, kind, timeout);}
|
|
|
double getCLLktPhase3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLLktPhase3(kind, timeout);}
|
|
|
void getCLLktPhase3(double *lkt, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLLktPhase3(lkt, kind, timeout);}
|
|
|
double getCLDemandValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLDemandValue(kind, timeout);}
|
|
|
void getCLDemandValue(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLDemandValue(cur, kind, timeout);}
|
|
|
double getCLActualValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLActualValue(kind, timeout);}
|
|
|
void getCLActualValue(double *cur, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLActualValue(cur, kind, timeout);}
|
|
|
double getEncoderSineSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderSineSignal(kind, timeout);}
|
|
|
void getEncoderSineSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderSineSignal(val, kind, timeout);}
|
|
|
double getEncoderCosineSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderCosineSignal(kind, timeout);}
|
|
|
void getEncoderCosineSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderCosineSignal(val, kind, timeout);}
|
|
|
double getEncoderIndexSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderIndexSignal(kind, timeout);}
|
|
|
void getEncoderIndexSignal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderIndexSignal(val, kind, timeout);}
|
|
|
double getEncoderHall1Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHall1Signal(kind, timeout);}
|
|
|
void getEncoderHall1Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHall1Signal(val, kind, timeout);}
|
|
|
double getEncoderHall2Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHall2Signal(kind, timeout);}
|
|
|
void getEncoderHall2Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHall2Signal(val, kind, timeout);}
|
|
|
double getEncoderHall3Signal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHall3Signal(kind, timeout);}
|
|
|
void getEncoderHall3Signal(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHall3Signal(val, kind, timeout);}
|
|
|
dword getEncoderHallDigSignal(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getEncoderHallDigSignal(kind, timeout);}
|
|
|
void getEncoderHallDigSignal(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getEncoderHallDigSignal(mask, kind, timeout);}
|
|
|
dword getDigitalInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDigitalInput(kind, timeout);}
|
|
|
void getDigitalInput(dword *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDigitalInput(inp, kind, timeout);}
|
|
|
double getAnalogInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAnalogInput(kind, timeout);}
|
|
|
void getAnalogInput(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAnalogInput(inp, kind, timeout);}
|
|
|
dword getXDigitalInput(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXDigitalInput(kind, timeout);}
|
|
|
void getXDigitalInput(dword *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXDigitalInput(inp, kind, timeout);}
|
|
|
double getXAnalogInput1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput1(kind, timeout);}
|
|
|
void getXAnalogInput1(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput1(inp, kind, timeout);}
|
|
|
double getXAnalogInput2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput2(kind, timeout);}
|
|
|
void getXAnalogInput2(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput2(inp, kind, timeout);}
|
|
|
double getXAnalogInput3(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput3(kind, timeout);}
|
|
|
void getXAnalogInput3(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput3(inp, kind, timeout);}
|
|
|
double getXAnalogInput4(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getXAnalogInput4(kind, timeout);}
|
|
|
void getXAnalogInput4(double *inp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getXAnalogInput4(inp, kind, timeout);}
|
|
|
dword getDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveStatus1(kind, timeout);}
|
|
|
void getDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveStatus1(mask, kind, timeout);}
|
|
|
dword getDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveStatus2(kind, timeout);}
|
|
|
void getDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveStatus2(mask, kind, timeout);}
|
|
|
double getCLI2tValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCLI2tValue(kind, timeout);}
|
|
|
void getCLI2tValue(double *val, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCLI2tValue(val, kind, timeout);}
|
|
|
int getAxisNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAxisNumber(kind, timeout);}
|
|
|
void getAxisNumber(int *num, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAxisNumber(num, kind, timeout);}
|
|
|
int getDaisyChainNumber(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDaisyChainNumber(kind, timeout);}
|
|
|
void getDaisyChainNumber(int *num, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDaisyChainNumber(num, kind, timeout);}
|
|
|
double getDriveTemperature(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveTemperature(kind, timeout);}
|
|
|
void getDriveTemperature(double *temp, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveTemperature(temp, kind, timeout);}
|
|
|
dword getDriveMaskValue(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveMaskValue(kind, timeout);}
|
|
|
void getDriveMaskValue(dword *str, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveMaskValue(str, kind, timeout);}
|
|
|
dword getDriveDisplay(int sidx, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveDisplay(sidx, kind, timeout);}
|
|
|
void getDriveDisplay(int sidx, dword *str, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveDisplay(sidx, str, kind, timeout);}
|
|
|
long getDriveSequenceLine(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveSequenceLine(kind, timeout);}
|
|
|
void getDriveSequenceLine(long *line, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveSequenceLine(line, kind, timeout);}
|
|
|
dword getDriveFuseStatus(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getDriveFuseStatus(kind, timeout);}
|
|
|
void getDriveFuseStatus(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getDriveFuseStatus(mask, kind, timeout);}
|
|
|
dword getIrqDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIrqDriveStatus1(kind, timeout);}
|
|
|
void getIrqDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIrqDriveStatus1(mask, kind, timeout);}
|
|
|
dword getIrqDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIrqDriveStatus2(kind, timeout);}
|
|
|
void getIrqDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIrqDriveStatus2(mask, kind, timeout);}
|
|
|
dword getAckDriveStatus1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAckDriveStatus1(kind, timeout);}
|
|
|
void getAckDriveStatus1(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAckDriveStatus1(mask, kind, timeout);}
|
|
|
dword getAckDriveStatus2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getAckDriveStatus2(kind, timeout);}
|
|
|
void getAckDriveStatus2(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getAckDriveStatus2(mask, kind, timeout);}
|
|
|
dword getIrqPendingAxisMask(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getIrqPendingAxisMask(kind, timeout);}
|
|
|
void getIrqPendingAxisMask(dword *mask, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getIrqPendingAxisMask(mask, kind, timeout);}
|
|
|
dword getCanFeedback1(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCanFeedback1(kind, timeout);}
|
|
|
void getCanFeedback1(dword *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCanFeedback1(val1, kind, timeout);}
|
|
|
dword getCanFeedback2(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getCanFeedback2(kind, timeout);}
|
|
|
void getCanFeedback2(dword *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getCanFeedback2(val1, kind, timeout);}
|
|
|
int getNbAvailableSlot(int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {return DsaBase::getNbAvailableSlot(kind, timeout);}
|
|
|
void getNbAvailableSlot(int *val1, int kind = GET_CURRENT, long timeout = DEF_TIMEOUT) {DsaBase::getNbAvailableSlot(val1, kind, timeout);}
|
|
|
|
|
|
void getPLProportionalGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLProportionalGain(kind, handler, param);}
|
|
|
void getPLProportionalGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLProportionalGain(handler, param);}
|
|
|
void getPLSpeedFeedbackGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedbackGain(kind, handler, param);}
|
|
|
void getPLSpeedFeedbackGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedbackGain(handler, param);}
|
|
|
void getPLForceFeedbackGain1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain1(kind, handler, param);}
|
|
|
void getPLForceFeedbackGain1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain1(handler, param);}
|
|
|
void getPLIntegratorGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorGain(kind, handler, param);}
|
|
|
void getPLIntegratorGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorGain(handler, param);}
|
|
|
void getPLAntiWindupGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAntiWindupGain(kind, handler, param);}
|
|
|
void getPLAntiWindupGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAntiWindupGain(handler, param);}
|
|
|
void getPLIntegratorLimitation(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorLimitation(kind, handler, param);}
|
|
|
void getPLIntegratorLimitation(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLIntegratorLimitation(handler, param);}
|
|
|
void getPLIntegratorMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getPLIntegratorMode(kind, handler, param);}
|
|
|
void getPLIntegratorMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getPLIntegratorMode(handler, param);}
|
|
|
void getPLSpeedFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFilter(kind, handler, param);}
|
|
|
void getPLSpeedFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFilter(handler, param);}
|
|
|
void getPLOutputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLOutputFilter(kind, handler, param);}
|
|
|
void getPLOutputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLOutputFilter(handler, param);}
|
|
|
void getCLInputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLInputFilter(kind, handler, param);}
|
|
|
void getCLInputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLInputFilter(handler, param);}
|
|
|
void getTtlSpecialFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTtlSpecialFilter(kind, handler, param);}
|
|
|
void getTtlSpecialFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTtlSpecialFilter(handler, param);}
|
|
|
void getPLForceFeedbackGain2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain2(kind, handler, param);}
|
|
|
void getPLForceFeedbackGain2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLForceFeedbackGain2(handler, param);}
|
|
|
void getPLSpeedFeedfwdGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedfwdGain(kind, handler, param);}
|
|
|
void getPLSpeedFeedfwdGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLSpeedFeedfwdGain(handler, param);}
|
|
|
void getPLAccFeedforwardGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAccFeedforwardGain(kind, handler, param);}
|
|
|
void getPLAccFeedforwardGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPLAccFeedforwardGain(handler, param);}
|
|
|
void getCLPhaseAdvanceFactor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceFactor(kind, handler, param);}
|
|
|
void getCLPhaseAdvanceFactor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceFactor(handler, param);}
|
|
|
void getAprInputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAprInputFilter(kind, handler, param);}
|
|
|
void getAprInputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAprInputFilter(handler, param);}
|
|
|
void getCLPhaseAdvanceShift(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceShift(kind, handler, param);}
|
|
|
void getCLPhaseAdvanceShift(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLPhaseAdvanceShift(handler, param);}
|
|
|
void getMinPositionRangeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinPositionRangeLimit(kind, handler, param);}
|
|
|
void getMinPositionRangeLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinPositionRangeLimit(handler, param);}
|
|
|
void getMaxPositionRangeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxPositionRangeLimit(kind, handler, param);}
|
|
|
void getMaxPositionRangeLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxPositionRangeLimit(handler, param);}
|
|
|
void getMaxProfileVelocity(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxProfileVelocity(kind, handler, param);}
|
|
|
void getMaxProfileVelocity(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxProfileVelocity(handler, param);}
|
|
|
void getMaxAcceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxAcceleration(kind, handler, param);}
|
|
|
void getMaxAcceleration(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxAcceleration(handler, param);}
|
|
|
void getFollowingErrorWindow(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFollowingErrorWindow(kind, handler, param);}
|
|
|
void getFollowingErrorWindow(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getFollowingErrorWindow(handler, param);}
|
|
|
void getVelocityErrorLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityErrorLimit(kind, handler, param);}
|
|
|
void getVelocityErrorLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityErrorLimit(handler, param);}
|
|
|
void getSwitchLimitMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getSwitchLimitMode(kind, handler, param);}
|
|
|
void getSwitchLimitMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getSwitchLimitMode(handler, param);}
|
|
|
void getEnableInputMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getEnableInputMode(kind, handler, param);}
|
|
|
void getEnableInputMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getEnableInputMode(handler, param);}
|
|
|
void getMinSoftPositionLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinSoftPositionLimit(kind, handler, param);}
|
|
|
void getMinSoftPositionLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMinSoftPositionLimit(handler, param);}
|
|
|
void getMaxSoftPositionLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxSoftPositionLimit(kind, handler, param);}
|
|
|
void getMaxSoftPositionLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMaxSoftPositionLimit(handler, param);}
|
|
|
void getProfileLimitMode(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getProfileLimitMode(kind, handler, param);}
|
|
|
void getProfileLimitMode(DsaDWordHandler handler, void *param = NULL) {DsaBase::getProfileLimitMode(handler, param);}
|
|
|
void getIOErrorEventMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIOErrorEventMask(kind, handler, param);}
|
|
|
void getIOErrorEventMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIOErrorEventMask(handler, param);}
|
|
|
void getPositionWindowTime(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindowTime(kind, handler, param);}
|
|
|
void getPositionWindowTime(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindowTime(handler, param);}
|
|
|
void getPositionWindow(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindow(kind, handler, param);}
|
|
|
void getPositionWindow(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionWindow(handler, param);}
|
|
|
void getHomingMethod(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingMethod(kind, handler, param);}
|
|
|
void getHomingMethod(DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingMethod(handler, param);}
|
|
|
void getHomingZeroSpeed(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingZeroSpeed(kind, handler, param);}
|
|
|
void getHomingZeroSpeed(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingZeroSpeed(handler, param);}
|
|
|
void getHomingAcceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingAcceleration(kind, handler, param);}
|
|
|
void getHomingAcceleration(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingAcceleration(handler, param);}
|
|
|
void getHomingFollowingLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFollowingLimit(kind, handler, param);}
|
|
|
void getHomingFollowingLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFollowingLimit(handler, param);}
|
|
|
void getHomingCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingCurrentLimit(kind, handler, param);}
|
|
|
void getHomingCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingCurrentLimit(handler, param);}
|
|
|
void getHomeOffset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomeOffset(kind, handler, param);}
|
|
|
void getHomeOffset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomeOffset(handler, param);}
|
|
|
void getHomingFixedMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFixedMvt(kind, handler, param);}
|
|
|
void getHomingFixedMvt(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFixedMvt(handler, param);}
|
|
|
void getHomingSwitchMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingSwitchMvt(kind, handler, param);}
|
|
|
void getHomingSwitchMvt(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingSwitchMvt(handler, param);}
|
|
|
void getHomingIndexMvt(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingIndexMvt(kind, handler, param);}
|
|
|
void getHomingIndexMvt(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingIndexMvt(handler, param);}
|
|
|
void getHomingFineTuningMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningMode(kind, handler, param);}
|
|
|
void getHomingFineTuningMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningMode(handler, param);}
|
|
|
void getHomingFineTuningValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningValue(kind, handler, param);}
|
|
|
void getHomingFineTuningValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getHomingFineTuningValue(handler, param);}
|
|
|
void getMotorPhaseCorrection(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMotorPhaseCorrection(kind, handler, param);}
|
|
|
void getMotorPhaseCorrection(DsaIntHandler handler, void *param = NULL) {DsaBase::getMotorPhaseCorrection(handler, param);}
|
|
|
void getSoftwareCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getSoftwareCurrentLimit(kind, handler, param);}
|
|
|
void getSoftwareCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getSoftwareCurrentLimit(handler, param);}
|
|
|
void getDriveControlMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getDriveControlMode(kind, handler, param);}
|
|
|
void getDriveControlMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getDriveControlMode(handler, param);}
|
|
|
void getDisplayMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getDisplayMode(kind, handler, param);}
|
|
|
void getDisplayMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getDisplayMode(handler, param);}
|
|
|
void getEncoderInversion(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderInversion(kind, handler, param);}
|
|
|
void getEncoderInversion(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderInversion(handler, param);}
|
|
|
void getPdrStepValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPdrStepValue(kind, handler, param);}
|
|
|
void getPdrStepValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPdrStepValue(handler, param);}
|
|
|
void getEncoderPhase1Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Offset(kind, handler, param);}
|
|
|
void getEncoderPhase1Offset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Offset(handler, param);}
|
|
|
void getEncoderPhase2Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Offset(kind, handler, param);}
|
|
|
void getEncoderPhase2Offset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Offset(handler, param);}
|
|
|
void getEncoderPhase1Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Factor(kind, handler, param);}
|
|
|
void getEncoderPhase1Factor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase1Factor(handler, param);}
|
|
|
void getEncoderPhase2Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Factor(kind, handler, param);}
|
|
|
void getEncoderPhase2Factor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase2Factor(handler, param);}
|
|
|
void getEncoderPhase3Offset(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Offset(kind, handler, param);}
|
|
|
void getEncoderPhase3Offset(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Offset(handler, param);}
|
|
|
void getEncoderIndexDistance(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexDistance(kind, handler, param);}
|
|
|
void getEncoderIndexDistance(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexDistance(handler, param);}
|
|
|
void getEncoderPhase3Factor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Factor(kind, handler, param);}
|
|
|
void getEncoderPhase3Factor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderPhase3Factor(handler, param);}
|
|
|
void getCLProportionalGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLProportionalGain(kind, handler, param);}
|
|
|
void getCLProportionalGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLProportionalGain(handler, param);}
|
|
|
void getCLIntegratorGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLIntegratorGain(kind, handler, param);}
|
|
|
void getCLIntegratorGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLIntegratorGain(handler, param);}
|
|
|
void getCLOutputFilter(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLOutputFilter(kind, handler, param);}
|
|
|
void getCLOutputFilter(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLOutputFilter(handler, param);}
|
|
|
void getCLCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentLimit(kind, handler, param);}
|
|
|
void getCLCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentLimit(handler, param);}
|
|
|
void getCLI2tCurrentLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tCurrentLimit(kind, handler, param);}
|
|
|
void getCLI2tCurrentLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tCurrentLimit(handler, param);}
|
|
|
void getCLI2tTimeLimit(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tTimeLimit(kind, handler, param);}
|
|
|
void getCLI2tTimeLimit(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tTimeLimit(handler, param);}
|
|
|
void getCLRegenMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCLRegenMode(kind, handler, param);}
|
|
|
void getCLRegenMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getCLRegenMode(handler, param);}
|
|
|
void getInitMode(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getInitMode(kind, handler, param);}
|
|
|
void getInitMode(DsaIntHandler handler, void *param = NULL) {DsaBase::getInitMode(handler, param);}
|
|
|
void getInitPulseLevel(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPulseLevel(kind, handler, param);}
|
|
|
void getInitPulseLevel(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPulseLevel(handler, param);}
|
|
|
void getInitMaxCurrent(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitMaxCurrent(kind, handler, param);}
|
|
|
void getInitMaxCurrent(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitMaxCurrent(handler, param);}
|
|
|
void getInitFinalPhase(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitFinalPhase(kind, handler, param);}
|
|
|
void getInitFinalPhase(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitFinalPhase(handler, param);}
|
|
|
void getInitTime(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitTime(kind, handler, param);}
|
|
|
void getInitTime(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitTime(handler, param);}
|
|
|
void getInitCurrentRate(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitCurrentRate(kind, handler, param);}
|
|
|
void getInitCurrentRate(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitCurrentRate(handler, param);}
|
|
|
void getInitPhaseRate(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPhaseRate(kind, handler, param);}
|
|
|
void getInitPhaseRate(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitPhaseRate(handler, param);}
|
|
|
void getInitInitialPhase(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitInitialPhase(kind, handler, param);}
|
|
|
void getInitInitialPhase(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getInitInitialPhase(handler, param);}
|
|
|
void getDriveFuseChecking(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseChecking(kind, handler, param);}
|
|
|
void getDriveFuseChecking(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseChecking(handler, param);}
|
|
|
void getMotorTempChecking(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getMotorTempChecking(kind, handler, param);}
|
|
|
void getMotorTempChecking(DsaDWordHandler handler, void *param = NULL) {DsaBase::getMotorTempChecking(handler, param);}
|
|
|
void getMonSourceType(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceType(sidx, kind, handler, param);}
|
|
|
void getMonSourceType(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceType(sidx, handler, param);}
|
|
|
void getMonSourceIndex(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceIndex(sidx, kind, handler, param);}
|
|
|
void getMonSourceIndex(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonSourceIndex(sidx, handler, param);}
|
|
|
void getMonDestIndex(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonDestIndex(sidx, kind, handler, param);}
|
|
|
void getMonDestIndex(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMonDestIndex(sidx, handler, param);}
|
|
|
void getMonOffset(int sidx, int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getMonOffset(sidx, kind, handler, param);}
|
|
|
void getMonOffset(int sidx, DsaLongHandler handler, void *param = NULL) {DsaBase::getMonOffset(sidx, handler, param);}
|
|
|
void getMonGain(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMonGain(sidx, kind, handler, param);}
|
|
|
void getMonGain(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMonGain(sidx, handler, param);}
|
|
|
void getXAnalogOffset(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOffset(sidx, kind, handler, param);}
|
|
|
void getXAnalogOffset(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOffset(sidx, handler, param);}
|
|
|
void getXAnalogGain(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogGain(sidx, kind, handler, param);}
|
|
|
void getXAnalogGain(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogGain(sidx, handler, param);}
|
|
|
void getSyncroInputMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputMask(kind, handler, param);}
|
|
|
void getSyncroInputMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputMask(handler, param);}
|
|
|
void getSyncroInputValue(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputValue(kind, handler, param);}
|
|
|
void getSyncroInputValue(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroInputValue(handler, param);}
|
|
|
void getSyncroOutputMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputMask(kind, handler, param);}
|
|
|
void getSyncroOutputMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputMask(handler, param);}
|
|
|
void getSyncroOutputValue(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputValue(kind, handler, param);}
|
|
|
void getSyncroOutputValue(DsaDWordHandler handler, void *param = NULL) {DsaBase::getSyncroOutputValue(handler, param);}
|
|
|
void getSyncroStartTimeout(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getSyncroStartTimeout(kind, handler, param);}
|
|
|
void getSyncroStartTimeout(DsaIntHandler handler, void *param = NULL) {DsaBase::getSyncroStartTimeout(handler, param);}
|
|
|
void getDigitalOutput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalOutput(kind, handler, param);}
|
|
|
void getDigitalOutput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalOutput(handler, param);}
|
|
|
void getXDigitalOutput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalOutput(kind, handler, param);}
|
|
|
void getXDigitalOutput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalOutput(handler, param);}
|
|
|
void getXAnalogOutput1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput1(kind, handler, param);}
|
|
|
void getXAnalogOutput1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput1(handler, param);}
|
|
|
void getXAnalogOutput2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput2(kind, handler, param);}
|
|
|
void getXAnalogOutput2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput2(handler, param);}
|
|
|
void getXAnalogOutput3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput3(kind, handler, param);}
|
|
|
void getXAnalogOutput3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput3(handler, param);}
|
|
|
void getXAnalogOutput4(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput4(kind, handler, param);}
|
|
|
void getXAnalogOutput4(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogOutput4(handler, param);}
|
|
|
void getAnalogOutput(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogOutput(kind, handler, param);}
|
|
|
void getAnalogOutput(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogOutput(handler, param);}
|
|
|
void getInterruptMask1(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask1(sidx, kind, handler, param);}
|
|
|
void getInterruptMask1(int sidx, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask1(sidx, handler, param);}
|
|
|
void getInterruptMask2(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask2(sidx, kind, handler, param);}
|
|
|
void getInterruptMask2(int sidx, DsaDWordHandler handler, void *param = NULL) {DsaBase::getInterruptMask2(sidx, handler, param);}
|
|
|
void getTriggerIrqMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIrqMask(kind, handler, param);}
|
|
|
void getTriggerIrqMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIrqMask(handler, param);}
|
|
|
void getTriggerIOMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIOMask(kind, handler, param);}
|
|
|
void getTriggerIOMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getTriggerIOMask(handler, param);}
|
|
|
void getTriggerMapOffset(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapOffset(kind, handler, param);}
|
|
|
void getTriggerMapOffset(DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapOffset(handler, param);}
|
|
|
void getTriggerMapSize(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapSize(kind, handler, param);}
|
|
|
void getTriggerMapSize(DsaIntHandler handler, void *param = NULL) {DsaBase::getTriggerMapSize(handler, param);}
|
|
|
void getRealtimeEnabledGlobal(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledGlobal(kind, handler, param);}
|
|
|
void getRealtimeEnabledGlobal(DsaIntHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledGlobal(handler, param);}
|
|
|
void getRealtimeValidMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeValidMask(kind, handler, param);}
|
|
|
void getRealtimeValidMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeValidMask(handler, param);}
|
|
|
void getRealtimeEnabledMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledMask(kind, handler, param);}
|
|
|
void getRealtimeEnabledMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimeEnabledMask(handler, param);}
|
|
|
void getRealtimePendingMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimePendingMask(kind, handler, param);}
|
|
|
void getRealtimePendingMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getRealtimePendingMask(handler, param);}
|
|
|
void getEblBaudrate(int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getEblBaudrate(kind, handler, param);}
|
|
|
void getEblBaudrate(DsaLongHandler handler, void *param = NULL) {DsaBase::getEblBaudrate(handler, param);}
|
|
|
void getIndirectAxisNumber(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectAxisNumber(kind, handler, param);}
|
|
|
void getIndirectAxisNumber(DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectAxisNumber(handler, param);}
|
|
|
void getIndirectRegisterIdx(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterIdx(kind, handler, param);}
|
|
|
void getIndirectRegisterIdx(DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterIdx(handler, param);}
|
|
|
void getIndirectRegisterSidx(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterSidx(kind, handler, param);}
|
|
|
void getIndirectRegisterSidx(DsaIntHandler handler, void *param = NULL) {DsaBase::getIndirectRegisterSidx(handler, param);}
|
|
|
void getConcatenatedMvt(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getConcatenatedMvt(kind, handler, param);}
|
|
|
void getConcatenatedMvt(DsaIntHandler handler, void *param = NULL) {DsaBase::getConcatenatedMvt(handler, param);}
|
|
|
void getProfileType(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getProfileType(sidx, kind, handler, param);}
|
|
|
void getProfileType(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getProfileType(sidx, handler, param);}
|
|
|
void getMvtLktNumber(int sidx, int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getMvtLktNumber(sidx, kind, handler, param);}
|
|
|
void getMvtLktNumber(int sidx, DsaIntHandler handler, void *param = NULL) {DsaBase::getMvtLktNumber(sidx, handler, param);}
|
|
|
void getMvtLktTime(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMvtLktTime(sidx, kind, handler, param);}
|
|
|
void getMvtLktTime(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMvtLktTime(sidx, handler, param);}
|
|
|
void getCameValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCameValue(kind, handler, param);}
|
|
|
void getCameValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCameValue(handler, param);}
|
|
|
void getBrakeDeceleration(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getBrakeDeceleration(kind, handler, param);}
|
|
|
void getBrakeDeceleration(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getBrakeDeceleration(handler, param);}
|
|
|
void getTargetPosition(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTargetPosition(sidx, kind, handler, param);}
|
|
|
void getTargetPosition(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getTargetPosition(sidx, handler, param);}
|
|
|
void getProfileVelocity(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileVelocity(sidx, kind, handler, param);}
|
|
|
void getProfileVelocity(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileVelocity(sidx, handler, param);}
|
|
|
void getProfileAcceleration(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileAcceleration(sidx, kind, handler, param);}
|
|
|
void getProfileAcceleration(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileAcceleration(sidx, handler, param);}
|
|
|
void getJerkTime(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getJerkTime(sidx, kind, handler, param);}
|
|
|
void getJerkTime(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getJerkTime(sidx, handler, param);}
|
|
|
void getProfileDeceleration(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileDeceleration(sidx, kind, handler, param);}
|
|
|
void getProfileDeceleration(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getProfileDeceleration(sidx, handler, param);}
|
|
|
void getEndVelocity(int sidx, int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEndVelocity(sidx, kind, handler, param);}
|
|
|
void getEndVelocity(int sidx, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEndVelocity(sidx, handler, param);}
|
|
|
void getCtrlSourceType(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceType(kind, handler, param);}
|
|
|
void getCtrlSourceType(DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceType(handler, param);}
|
|
|
void getCtrlSourceIndex(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceIndex(kind, handler, param);}
|
|
|
void getCtrlSourceIndex(DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlSourceIndex(handler, param);}
|
|
|
void getCtrlShiftFactor(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlShiftFactor(kind, handler, param);}
|
|
|
void getCtrlShiftFactor(DsaIntHandler handler, void *param = NULL) {DsaBase::getCtrlShiftFactor(handler, param);}
|
|
|
void getCtrlOffset(int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getCtrlOffset(kind, handler, param);}
|
|
|
void getCtrlOffset(DsaLongHandler handler, void *param = NULL) {DsaBase::getCtrlOffset(handler, param);}
|
|
|
void getCtrlGain(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCtrlGain(kind, handler, param);}
|
|
|
void getCtrlGain(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCtrlGain(handler, param);}
|
|
|
void getMotorKTFactor(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMotorKTFactor(kind, handler, param);}
|
|
|
void getMotorKTFactor(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getMotorKTFactor(handler, param);}
|
|
|
void getPositionCtrlError(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionCtrlError(kind, handler, param);}
|
|
|
void getPositionCtrlError(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionCtrlError(handler, param);}
|
|
|
void getPositionMaxError(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionMaxError(kind, handler, param);}
|
|
|
void getPositionMaxError(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionMaxError(handler, param);}
|
|
|
void getPositionDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionDemandValue(kind, handler, param);}
|
|
|
void getPositionDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionDemandValue(handler, param);}
|
|
|
void getPositionActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionActualValue(kind, handler, param);}
|
|
|
void getPositionActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getPositionActualValue(handler, param);}
|
|
|
void getVelocityDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityDemandValue(kind, handler, param);}
|
|
|
void getVelocityDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityDemandValue(handler, param);}
|
|
|
void getVelocityActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityActualValue(kind, handler, param);}
|
|
|
void getVelocityActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getVelocityActualValue(handler, param);}
|
|
|
void getAccDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccDemandValue(kind, handler, param);}
|
|
|
void getAccDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccDemandValue(handler, param);}
|
|
|
void getAccActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccActualValue(kind, handler, param);}
|
|
|
void getAccActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAccActualValue(handler, param);}
|
|
|
void getRefDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRefDemandValue(kind, handler, param);}
|
|
|
void getRefDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getRefDemandValue(handler, param);}
|
|
|
void getDriveControlMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveControlMask(kind, handler, param);}
|
|
|
void getDriveControlMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveControlMask(handler, param);}
|
|
|
void getCLCurrentPhase1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase1(kind, handler, param);}
|
|
|
void getCLCurrentPhase1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase1(handler, param);}
|
|
|
void getCLCurrentPhase2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase2(kind, handler, param);}
|
|
|
void getCLCurrentPhase2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase2(handler, param);}
|
|
|
void getCLCurrentPhase3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase3(kind, handler, param);}
|
|
|
void getCLCurrentPhase3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLCurrentPhase3(handler, param);}
|
|
|
void getCLLktPhase1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase1(kind, handler, param);}
|
|
|
void getCLLktPhase1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase1(handler, param);}
|
|
|
void getCLLktPhase2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase2(kind, handler, param);}
|
|
|
void getCLLktPhase2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase2(handler, param);}
|
|
|
void getCLLktPhase3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase3(kind, handler, param);}
|
|
|
void getCLLktPhase3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLLktPhase3(handler, param);}
|
|
|
void getCLDemandValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLDemandValue(kind, handler, param);}
|
|
|
void getCLDemandValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLDemandValue(handler, param);}
|
|
|
void getCLActualValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLActualValue(kind, handler, param);}
|
|
|
void getCLActualValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLActualValue(handler, param);}
|
|
|
void getEncoderSineSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderSineSignal(kind, handler, param);}
|
|
|
void getEncoderSineSignal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderSineSignal(handler, param);}
|
|
|
void getEncoderCosineSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderCosineSignal(kind, handler, param);}
|
|
|
void getEncoderCosineSignal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderCosineSignal(handler, param);}
|
|
|
void getEncoderIndexSignal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexSignal(kind, handler, param);}
|
|
|
void getEncoderIndexSignal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderIndexSignal(handler, param);}
|
|
|
void getEncoderHall1Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall1Signal(kind, handler, param);}
|
|
|
void getEncoderHall1Signal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall1Signal(handler, param);}
|
|
|
void getEncoderHall2Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall2Signal(kind, handler, param);}
|
|
|
void getEncoderHall2Signal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall2Signal(handler, param);}
|
|
|
void getEncoderHall3Signal(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall3Signal(kind, handler, param);}
|
|
|
void getEncoderHall3Signal(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getEncoderHall3Signal(handler, param);}
|
|
|
void getEncoderHallDigSignal(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getEncoderHallDigSignal(kind, handler, param);}
|
|
|
void getEncoderHallDigSignal(DsaDWordHandler handler, void *param = NULL) {DsaBase::getEncoderHallDigSignal(handler, param);}
|
|
|
void getDigitalInput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalInput(kind, handler, param);}
|
|
|
void getDigitalInput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDigitalInput(handler, param);}
|
|
|
void getAnalogInput(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogInput(kind, handler, param);}
|
|
|
void getAnalogInput(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getAnalogInput(handler, param);}
|
|
|
void getXDigitalInput(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalInput(kind, handler, param);}
|
|
|
void getXDigitalInput(DsaDWordHandler handler, void *param = NULL) {DsaBase::getXDigitalInput(handler, param);}
|
|
|
void getXAnalogInput1(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput1(kind, handler, param);}
|
|
|
void getXAnalogInput1(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput1(handler, param);}
|
|
|
void getXAnalogInput2(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput2(kind, handler, param);}
|
|
|
void getXAnalogInput2(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput2(handler, param);}
|
|
|
void getXAnalogInput3(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput3(kind, handler, param);}
|
|
|
void getXAnalogInput3(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput3(handler, param);}
|
|
|
void getXAnalogInput4(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput4(kind, handler, param);}
|
|
|
void getXAnalogInput4(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getXAnalogInput4(handler, param);}
|
|
|
void getDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus1(kind, handler, param);}
|
|
|
void getDriveStatus1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus1(handler, param);}
|
|
|
void getDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus2(kind, handler, param);}
|
|
|
void getDriveStatus2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveStatus2(handler, param);}
|
|
|
void getCLI2tValue(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tValue(kind, handler, param);}
|
|
|
void getCLI2tValue(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getCLI2tValue(handler, param);}
|
|
|
void getAxisNumber(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getAxisNumber(kind, handler, param);}
|
|
|
void getAxisNumber(DsaIntHandler handler, void *param = NULL) {DsaBase::getAxisNumber(handler, param);}
|
|
|
void getDaisyChainNumber(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getDaisyChainNumber(kind, handler, param);}
|
|
|
void getDaisyChainNumber(DsaIntHandler handler, void *param = NULL) {DsaBase::getDaisyChainNumber(handler, param);}
|
|
|
void getDriveTemperature(int kind, DsaDoubleHandler handler, void *param = NULL) {DsaBase::getDriveTemperature(kind, handler, param);}
|
|
|
void getDriveTemperature(DsaDoubleHandler handler, void *param = NULL) {DsaBase::getDriveTemperature(handler, param);}
|
|
|
void getDriveMaskValue(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveMaskValue(kind, handler, param);}
|
|
|
void getDriveMaskValue(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveMaskValue(handler, param);}
|
|
|
void getDriveDisplay(int sidx, int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveDisplay(sidx, kind, handler, param);}
|
|
|
void getDriveDisplay(int sidx, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveDisplay(sidx, handler, param);}
|
|
|
void getDriveSequenceLine(int kind, DsaLongHandler handler, void *param = NULL) {DsaBase::getDriveSequenceLine(kind, handler, param);}
|
|
|
void getDriveSequenceLine(DsaLongHandler handler, void *param = NULL) {DsaBase::getDriveSequenceLine(handler, param);}
|
|
|
void getDriveFuseStatus(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseStatus(kind, handler, param);}
|
|
|
void getDriveFuseStatus(DsaDWordHandler handler, void *param = NULL) {DsaBase::getDriveFuseStatus(handler, param);}
|
|
|
void getIrqDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus1(kind, handler, param);}
|
|
|
void getIrqDriveStatus1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus1(handler, param);}
|
|
|
void getIrqDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus2(kind, handler, param);}
|
|
|
void getIrqDriveStatus2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqDriveStatus2(handler, param);}
|
|
|
void getAckDriveStatus1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus1(kind, handler, param);}
|
|
|
void getAckDriveStatus1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus1(handler, param);}
|
|
|
void getAckDriveStatus2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus2(kind, handler, param);}
|
|
|
void getAckDriveStatus2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getAckDriveStatus2(handler, param);}
|
|
|
void getIrqPendingAxisMask(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqPendingAxisMask(kind, handler, param);}
|
|
|
void getIrqPendingAxisMask(DsaDWordHandler handler, void *param = NULL) {DsaBase::getIrqPendingAxisMask(handler, param);}
|
|
|
void getCanFeedback1(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback1(kind, handler, param);}
|
|
|
void getCanFeedback1(DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback1(handler, param);}
|
|
|
void getCanFeedback2(int kind, DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback2(kind, handler, param);}
|
|
|
void getCanFeedback2(DsaDWordHandler handler, void *param = NULL) {DsaBase::getCanFeedback2(handler, param);}
|
|
|
void getNbAvailableSlot(int kind, DsaIntHandler handler, void *param = NULL) {DsaBase::getNbAvailableSlot(kind, handler, param);}
|
|
|
void getNbAvailableSlot(DsaIntHandler handler, void *param = NULL) {DsaBase::getNbAvailableSlot(handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaGPModuleGroup class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaGPModuleGroup: public DsaBase {
|
|
|
/* constructors */
|
|
|
private:
|
|
|
void _Group(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_gp_module_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
protected:
|
|
|
DsaGPModuleGroup(void) {
|
|
|
}
|
|
|
public:
|
|
|
DsaGPModuleGroup(DsaGPModuleGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaBase &obj) {
|
|
|
if (!dsa_is_valid_gp_module_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
dsa = obj.dsa;
|
|
|
}
|
|
|
DsaGPModuleGroup(int max, ...) {
|
|
|
va_list arg;
|
|
|
va_start(arg, max);
|
|
|
ERRCHK(dsa_create_gp_module_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, va_arg(arg, DsaBase *)->dsa));
|
|
|
va_end(arg);
|
|
|
}
|
|
|
DsaGPModuleGroup(int max, DsaGPModuleBase *list[]) {
|
|
|
ERRCHK(dsa_create_gp_module_group(&dsa, max));
|
|
|
for(int i = 0; i < max; i++)
|
|
|
ERRCHK(dsa_set_group_item(dsa, i, list[i]->dsa));
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2) {
|
|
|
_Group(2, &d1, &d2);
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2, DsaGPModuleBase d3) {
|
|
|
_Group(3, &d1, &d2, &d3);
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2, DsaGPModuleBase d3, DsaGPModuleBase d4) {
|
|
|
_Group(4, &d1, &d2, &d3, &d4);
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2, DsaGPModuleBase d3, DsaGPModuleBase d4, DsaGPModuleBase d5) {
|
|
|
_Group(5, &d1, &d2, &d3, &d4, &d5);
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2, DsaGPModuleBase d3, DsaGPModuleBase d4, DsaGPModuleBase d5, DsaGPModuleBase d6) {
|
|
|
_Group(6, &d1, &d2, &d3, &d4, &d5, &d6);
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2, DsaGPModuleBase d3, DsaGPModuleBase d4, DsaGPModuleBase d5, DsaGPModuleBase d6, DsaGPModuleBase d7) {
|
|
|
_Group(7, &d1, &d2, &d3, &d4, &d5, &d6, &d7);
|
|
|
}
|
|
|
DsaGPModuleGroup(DsaGPModuleBase d1, DsaGPModuleBase d2, DsaGPModuleBase d3, DsaGPModuleBase d4, DsaGPModuleBase d5, DsaGPModuleBase d6, DsaGPModuleBase d7, DsaGPModuleBase d8) {
|
|
|
_Group(8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8);
|
|
|
}
|
|
|
/* operators */
|
|
|
public:
|
|
|
DsaGPModuleGroup operator = (DsaGPModuleGroup &obj) {
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
DsaGPModuleGroup operator = (DsaBase &obj) {
|
|
|
if (!dsa_is_valid_gp_module_group(obj.dsa))
|
|
|
throw DsaException(DSA_EBADPARAM);
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
ERRCHK(dsa_destroy(&dsa));
|
|
|
dsa = obj.dsa;
|
|
|
return *this;
|
|
|
}
|
|
|
/* functions */
|
|
|
public:
|
|
|
DsaGPModuleBase getGroupItem(int pos) {return DsaBase::getGroupItem(pos);}
|
|
|
void quickStop(int mode, dword flags, long timeout = DEF_TIMEOUT) {DsaBase::quickStop(mode, flags, timeout);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, timeout);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, long timeout = DEF_TIMEOUT) {DsaBase::executeCommand(cmd, params, count, fast, ereport, timeout);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterInt64(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, timeout);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, long timeout = DEF_TIMEOUT) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, timeout);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, long timeout = DEF_TIMEOUT) {DsaBase::setFloatRegister(typ, idx, sidx, val, timeout);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, long timeout = DEF_TIMEOUT) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, timeout);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, timeout);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, timeout);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusEqual(mask, ref, timeout);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, long timeout = DEF_TIMEOUT) {DsaBase::grpWaitORStatusNotEqual(mask, ref, timeout);}
|
|
|
void setTraceModeMvt(double time, bool endm, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeMvt(time, endm, timeout);}
|
|
|
void setTraceModePos(double time, double pos, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModePos(time, pos, timeout);}
|
|
|
void setTraceModeDev(double time, long level, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeDev(time, level, timeout);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeIso(time, level, conv, timeout);}
|
|
|
void setTraceModeImmediate(double time, long timeout = DEF_TIMEOUT) {DsaBase::setTraceModeImmediate(time, timeout);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, long timeout = DEF_TIMEOUT) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, timeout);}
|
|
|
void syncTraceEnable(bool enable, long timeout = DEF_TIMEOUT) {DsaBase::syncTraceEnable(enable, timeout);}
|
|
|
void syncTraceForceTrigger(long timeout = DEF_TIMEOUT) {DsaBase::syncTraceForceTrigger(timeout);}
|
|
|
|
|
|
void quickStop(int mode, dword flags, DsaHandler handler, void *param = NULL) {DsaBase::quickStop(mode, flags, handler, param);}
|
|
|
void executeCommand(int cmd, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, long par2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, long par1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, int typ1, double par1, int conv1, int typ2, double par2, int conv2, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, typ1, par1, conv1, typ2, par2, conv2, fast, ereport, handler, param);}
|
|
|
void executeCommand(int cmd, DsaCommandParam *params, int count, bool fast, bool ereport, DsaHandler handler, void *param = NULL) {DsaBase::executeCommand(cmd, params, count, fast, ereport, handler, param);}
|
|
|
void setRegister(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt32(int typ, unsigned idx, int sidx, long val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterInt64(int typ, unsigned idx, int sidx, eint64 val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterInt64(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat32(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat32(typ, idx, sidx, val, handler, param);}
|
|
|
void setRegisterFloat64(int typ, unsigned idx, int sidx, double val, DsaHandler handler, void *param = NULL) {DsaBase::setRegisterFloat64(typ, idx, sidx, val, handler, param);}
|
|
|
void setFloatRegister(int typ, unsigned idx, int sidx, float val, DsaHandler handler, void *param = NULL) {DsaBase::setFloatRegister(typ, idx, sidx, val, handler, param);}
|
|
|
void setArray(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArray(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt32(int typ, unsigned idx, unsigned nidx, int sidx, long *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayInt64(int typ, unsigned idx, unsigned nidx, int sidx, eint64 *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayInt64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat32(int typ, unsigned idx, unsigned nidx, int sidx, float *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat32(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setArrayFloat64(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, DsaHandler handler, void *param = NULL) {DsaBase::setArrayFloat64(typ, idx, nidx, sidx, val, offset, handler, param);}
|
|
|
void setIsoRegister(int typ, unsigned idx, int sidx, double val, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoRegister(typ, idx, sidx, val, conv, handler, param);}
|
|
|
void setIsoArray(int typ, unsigned idx, unsigned nidx, int sidx, double *val, int offset, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setIsoArray(typ, idx, nidx, sidx, val, offset, conv, handler, param);}
|
|
|
void grpWaitAndStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitAndStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitAndStatusNotEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusEqual(mask, ref, handler, param);}
|
|
|
void grpWaitORStatusNotEqual(DsaStatus *mask, DsaStatus *ref, DsaHandler handler, void *param = NULL) {DsaBase::grpWaitORStatusNotEqual(mask, ref, handler, param);}
|
|
|
void setTraceModeMvt(double time, bool endm, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeMvt(time, endm, handler, param);}
|
|
|
void setTraceModePos(double time, double pos, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModePos(time, pos, handler, param);}
|
|
|
void setTraceModeDev(double time, long level, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeDev(time, level, handler, param);}
|
|
|
void setTraceModeIso(double time, void *level, int conv, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeIso(time, level, conv, handler, param);}
|
|
|
void setTraceModeImmediate(double time, DsaHandler handler, void *param = NULL) {DsaBase::setTraceModeImmediate(time, handler, param);}
|
|
|
void traceAcquisition(int typ1, int idx1, int sidx1, int typ2, int idx2, int sidx2, DsaHandler handler, void *param = NULL) {DsaBase::traceAcquisition(typ1, idx1, sidx1, typ2, idx2, sidx2, handler, param);}
|
|
|
void syncTraceEnable(bool enable, DsaHandler handler, void *param = NULL) {DsaBase::syncTraceEnable(enable, handler, param);}
|
|
|
void syncTraceForceTrigger(DsaHandler handler, void *param = NULL) {DsaBase::syncTraceForceTrigger(handler, param);}
|
|
|
|
|
|
void diag(char_cp file_name, int line, int err) {DsaBase::diag(file_name, line, err);}
|
|
|
void sdiag(char_p str, char_cp file_name, int line, int err) {DsaBase::sdiag(str, file_name, line, err);}
|
|
|
void fdiag(char_cp output_file_name, char_cp file_name, int line, int err) {DsaBase::fdiag(output_file_name, file_name, line, err);}
|
|
|
int getGroupSize() {return DsaBase::getGroupSize();}
|
|
|
void cancelStatusWait() {DsaBase::cancelStatusWait();}
|
|
|
void grpCancelStatusWait() {DsaBase::grpCancelStatusWait();}
|
|
|
void commitAsyncTrans(DsaHandler handler, void *param = NULL) {DsaBase::commitAsyncTrans(handler, param);}
|
|
|
|
|
|
/* commands */
|
|
|
void resetError(long timeout = DEF_TIMEOUT) {DsaBase::resetError(timeout);}
|
|
|
void executeSequence(int label, long timeout = DEF_TIMEOUT) {DsaBase::executeSequence(label, timeout);}
|
|
|
void executeSequenceInThread(int label, int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::executeSequenceInThread(label, threadNr, timeout);}
|
|
|
void stopSequenceInThread(int threadNr, long timeout = DEF_TIMEOUT) {DsaBase::stopSequenceInThread(threadNr, timeout);}
|
|
|
void stopSequence(long timeout = DEF_TIMEOUT) {DsaBase::stopSequence(timeout);}
|
|
|
void editSequence(long timeout = DEF_TIMEOUT) {DsaBase::editSequence(timeout);}
|
|
|
void exitSequence(long timeout = DEF_TIMEOUT) {DsaBase::exitSequence(timeout);}
|
|
|
void saveParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::saveParameters(what, timeout);}
|
|
|
void loadParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::loadParameters(what, timeout);}
|
|
|
void defaultParameters(int what, long timeout = DEF_TIMEOUT) {DsaBase::defaultParameters(what, timeout);}
|
|
|
void waitMovement(long timeout = DEF_TIMEOUT) {DsaBase::waitMovement(timeout);}
|
|
|
void waitPosition(double pos, long timeout = DEF_TIMEOUT) {DsaBase::waitPosition(pos, timeout);}
|
|
|
void waitTime(double time, long timeout = DEF_TIMEOUT) {DsaBase::waitTime(time, timeout);}
|
|
|
void waitWindow(long timeout = DEF_TIMEOUT) {DsaBase::waitWindow(timeout);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSet(typ, idx, sidx, mask, timeout);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClear(typ, idx, sidx, mask, timeout);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, timeout);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, timeout);}
|
|
|
void waitWindowUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitWindowUserChannel(channel, timeout);}
|
|
|
void waitMovementUserChannel(int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitMovementUserChannel(channel, timeout);}
|
|
|
void waitTimeUserChannel(double time, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitTimeUserChannel(time, channel, timeout);}
|
|
|
void waitPositionUserChannel(double position, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitPositionUserChannel(position, channel, timeout);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, timeout);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, long timeout = DEF_TIMEOUT) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, timeout);}
|
|
|
int getFamily() {return DsaBase::getFamily();}
|
|
|
|
|
|
void resetError(DsaHandler handler, void *param = NULL) {DsaBase::resetError(handler, param);}
|
|
|
void executeSequence(int label, DsaHandler handler, void *param = NULL) {DsaBase::executeSequence(label, handler, param);}
|
|
|
void executeSequenceInThread(int label, int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::executeSequenceInThread(label, threadNr, handler, param);}
|
|
|
void stopSequenceInThread(int threadNr, DsaHandler handler, void *param = NULL) {DsaBase::stopSequenceInThread(threadNr, handler, param);}
|
|
|
void stopSequence(DsaHandler handler, void *param = NULL) {DsaBase::stopSequence(handler, param);}
|
|
|
void editSequence(DsaHandler handler, void *param = NULL) {DsaBase::editSequence(handler, param);}
|
|
|
void exitSequence(DsaHandler handler, void *param = NULL) {DsaBase::exitSequence(handler, param);}
|
|
|
void saveParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::saveParameters(what, handler, param);}
|
|
|
void loadParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::loadParameters(what, handler, param);}
|
|
|
void defaultParameters(int what, DsaHandler handler, void *param = NULL) {DsaBase::defaultParameters(what, handler, param);}
|
|
|
void waitMovement(DsaHandler handler, void *param = NULL) {DsaBase::waitMovement(handler, param);}
|
|
|
void waitPosition(double pos, DsaHandler handler, void *param = NULL) {DsaBase::waitPosition(pos, handler, param);}
|
|
|
void waitTime(double time, DsaHandler handler, void *param = NULL) {DsaBase::waitTime(time, handler, param);}
|
|
|
void waitWindow(DsaHandler handler, void *param = NULL) {DsaBase::waitWindow(handler, param);}
|
|
|
void waitBitSet(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSet(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitBitClear(int typ, int idx, int sidx, dword mask, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClear(typ, idx, sidx, mask, handler, param);}
|
|
|
void waitSgnRegisterGreater(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreater(typ, idx, sidx, value, handler, param);}
|
|
|
void waitSgnRegisterLower(int typ, int idx, int sidx, double value, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLower(typ, idx, sidx, value, handler, param);}
|
|
|
void waitWindowUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitWindowUserChannel(channel, handler, param);}
|
|
|
void waitMovementUserChannel(int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitMovementUserChannel(channel, handler, param);}
|
|
|
void waitTimeUserChannel(double time, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitTimeUserChannel(time, channel, handler, param);}
|
|
|
void waitPositionUserChannel(double position, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitPositionUserChannel(position, channel, handler, param);}
|
|
|
void waitSgnRegisterGreaterUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterGreaterUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitSgnRegisterLowerUserChannel(int typ, int idx, int sidx, double value, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitSgnRegisterLowerUserChannel(typ, idx, sidx, value, channel, handler, param);}
|
|
|
void waitBitSetUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitSetUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
void waitBitClearUserChannel(int typ, int idx, int sidx, dword mask, int channel, DsaHandler handler, void *param = NULL) {DsaBase::waitBitClearUserChannel(typ, idx, sidx, mask, channel, handler, param);}
|
|
|
};
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaAcquisition class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaAcquisition {
|
|
|
protected:
|
|
|
DSA_ACQUISITION *acq;
|
|
|
/* constructors */
|
|
|
public:
|
|
|
DsaAcquisition(DsaDeviceBase dev) {
|
|
|
acq = NULL;
|
|
|
ERRCHK(dsa_create_acquisition(&acq, dev.getDsaStructure()));
|
|
|
}
|
|
|
public:
|
|
|
~DsaAcquisition(void) {
|
|
|
if (acq)
|
|
|
ERRCHK(dsa_destroy_acquisition(&acq));
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
/*
|
|
|
* ACQUISITION TRIGGER mode
|
|
|
*/
|
|
|
enum {TRIG_IMMEDIATE = 0}; /* trig immediately */
|
|
|
enum {TRIG_START_MOVE = 1}; /* trig on move start */
|
|
|
enum {TRIG_END_MOVE = 2}; /* trig on move end */
|
|
|
enum {TRIG_POSITION = 3}; /* trig on position level crossed */
|
|
|
enum {TRIG_TRACE = 4}; /* trig on trace level crossed */
|
|
|
enum {TRIG_EXTERNAL = 5}; /* external trig */
|
|
|
enum {TRIG_REGISTER = 6}; /* trig on given value of register */
|
|
|
enum {TRIG_BIT_FIELD_STATE = 7}; /* trig on bit field state */
|
|
|
enum {TRIG_BIT_FIELD_EDGE = 8}; /* trig on bit field riging or falling edge */
|
|
|
|
|
|
/*
|
|
|
* ACQUISITION SYNCHRO mode
|
|
|
*/
|
|
|
enum {SYNCRO_MODE_NONE = 0}; /* each device will have its own time rate, given time and number of point will be respected */
|
|
|
enum {SYNCRO_MODE_COMMON_STI = 1}; /* a common time rate is choosen for all device, only given number of point will be respected */
|
|
|
enum {SYNCRO_MODE_MIN_STI = 2}; /* the time rate of the fastest device is choosen as reference, only given number of point will be respected */
|
|
|
|
|
|
/*
|
|
|
* ACQUISITION UPLOAD mode
|
|
|
*/
|
|
|
enum {UPLOAD_MODE_AVOID_FAST = 1}; /* no traces will be uploaded as fast */
|
|
|
|
|
|
public:
|
|
|
void configTrace(DsaDeviceBase dev, int traceIdx, int typ, int idx, int sidx) {
|
|
|
ERRCHK(dsa_acquisition_config_trace(acq, dev.getDsaStructure(), traceIdx, typ, idx, sidx));
|
|
|
}
|
|
|
|
|
|
void configTrigger(DsaDeviceBase dev, int trigMode, int trigTraceIdx, double trigLevel, int trigLevelConv) {
|
|
|
ERRCHK(dsa_acquisition_config_trigger(acq, dev.getDsaStructure(), trigMode, trigTraceIdx, trigLevel, trigLevelConv));
|
|
|
}
|
|
|
|
|
|
void configFrequency(int nbPoints, double totalTime, int synchroMode, int uploadMode) {
|
|
|
ERRCHK(dsa_acquisition_config_frequency(acq, nbPoints, totalTime, synchroMode, uploadMode));
|
|
|
}
|
|
|
|
|
|
void configImmediateTrigger(DsaDeviceBase dev) {
|
|
|
ERRCHK(dsa_acquisition_config_immediate_trigger(acq, dev.getDsaStructure()));
|
|
|
}
|
|
|
|
|
|
void configBeginOfMovementTrigger(DsaDeviceBase dev, int ipolGrp, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_begin_of_movement_trigger(acq, dev.getDsaStructure(), ipolGrp, delay));
|
|
|
}
|
|
|
|
|
|
void configEndOfMovementTrigger(DsaDeviceBase dev, int ipolGrp, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_end_of_movement_trigger(acq, dev.getDsaStructure(), ipolGrp, delay));
|
|
|
}
|
|
|
|
|
|
void configPositionTrigger(DsaDeviceBase dev, int edge, double position, int conv, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_position_trigger(acq, dev.getDsaStructure(), edge, position, conv, delay));
|
|
|
}
|
|
|
|
|
|
void configPositionInt64Trigger(DsaDeviceBase dev, int edge, eint64 inc_position, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_position_int64_trigger(acq, dev.getDsaStructure(), edge, inc_position, delay));
|
|
|
}
|
|
|
|
|
|
void configTraceIdxTrigger(DsaDeviceBase dev, int edge, int trace_idx, double value, int conv, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_trace_idx_trigger(acq, dev.getDsaStructure(), edge, trace_idx, value, conv, delay));
|
|
|
}
|
|
|
|
|
|
void configTraceIdxInt32Trigger(DsaDeviceBase dev, int edge, int trace_idx, int value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_trace_idx_int32_trigger(acq, dev.getDsaStructure(), edge, trace_idx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configTraceIdxInt64Trigger(DsaDeviceBase dev, int edge, int trace_idx, eint64 value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_trace_idx_int64_trigger(acq, dev.getDsaStructure(), edge, trace_idx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configTraceIdxFloat32Trigger(DsaDeviceBase dev, int edge, int trace_idx, float value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_trace_idx_float32_trigger(acq, dev.getDsaStructure(), edge, trace_idx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configTraceIdxFloat64Trigger(DsaDeviceBase dev, int edge, int trace_idx, double value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_trace_idx_float64_trigger(acq, dev.getDsaStructure(), edge, trace_idx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configRegisterTrigger(DsaDeviceBase dev, int edge, int typ, int idx, int sidx, double value, int conv, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_register_trigger(acq, dev.getDsaStructure(), edge, typ, idx, sidx, value, conv, delay));
|
|
|
}
|
|
|
|
|
|
void configRegisterInt32Trigger(DsaDeviceBase dev, int edge, int typ, int idx, int sidx, int value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_register_int32_trigger(acq, dev.getDsaStructure(), edge, typ, idx, sidx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configRegisterInt64Trigger(DsaDeviceBase dev, int edge, int typ, int idx, int sidx, eint64 value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_register_int64_trigger(acq, dev.getDsaStructure(), edge, typ, idx, sidx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configRegisterFloat32Trigger(DsaDeviceBase dev, int edge, int typ, int idx, int sidx, float value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_register_float32_trigger(acq, dev.getDsaStructure(), edge, typ, idx, sidx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configRegisterFloat64Trigger(DsaDeviceBase dev, int edge, int typ, int idx, int sidx, int value, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_register_float64_trigger(acq, dev.getDsaStructure(), edge, typ, idx, sidx, value, delay));
|
|
|
}
|
|
|
|
|
|
void configInt32BitFieldStateTrigger(DsaDeviceBase dev, int typ, int idx, int sidx, dword low_state_mask, dword high_state_mask, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_int32_bit_field_state_trigger(acq, dev.getDsaStructure(), typ, idx, sidx, low_state_mask, high_state_mask, delay));
|
|
|
}
|
|
|
|
|
|
void configInt64BitFieldStateTrigger(DsaDeviceBase dev, int typ, int idx, int sidx, eint64 low_state_mask, eint64 high_state_mask, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_int64_bit_field_state_trigger(acq, dev.getDsaStructure(), typ, idx, sidx, low_state_mask, high_state_mask, delay));
|
|
|
}
|
|
|
|
|
|
void configInt32BitFieldChangeTrigger(DsaDeviceBase dev, int typ, int idx, int sidx, dword rising_edge_mask, dword falling_edge_mask, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_int32_bit_field_change_trigger(acq, dev.getDsaStructure(), typ, idx, sidx, rising_edge_mask, falling_edge_mask, delay));
|
|
|
}
|
|
|
|
|
|
void configInt64BitFieldChangeTrigger(DsaDeviceBase dev, int typ, int idx, int sidx, eint64 rising_edge_mask, eint64 falling_edge_mask, double delay) {
|
|
|
ERRCHK(dsa_acquisition_config_int64_bit_field_change_trigger(acq, dev.getDsaStructure(), typ, idx, sidx, rising_edge_mask, falling_edge_mask, delay));
|
|
|
}
|
|
|
|
|
|
double getRealTotalTime() {
|
|
|
double totalTime;
|
|
|
|
|
|
ERRCHK(dsa_acquisition_get_real_total_time(acq, &totalTime));
|
|
|
return totalTime;
|
|
|
}
|
|
|
|
|
|
int getTraceRealNbPoints(DsaDevice dev, int traceIdx) {
|
|
|
int nbPoints;
|
|
|
|
|
|
ERRCHK(dsa_acquisition_get_trace_real_nb_points(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, &nbPoints));
|
|
|
return nbPoints;
|
|
|
}
|
|
|
|
|
|
#ifdef DSA_IMPL_S
|
|
|
void acquire(int timeout) {
|
|
|
ERRCHK(dsa_acquisition_acquire_s(acq, timeout));
|
|
|
}
|
|
|
#endif /* DSA_IMPL_S */
|
|
|
|
|
|
#ifdef DSA_IMPL_A
|
|
|
void acquire(DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_acquisition_acquire_a(acq, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
#endif /* DSA_IMPL_A */
|
|
|
|
|
|
|
|
|
void stopAcquire() {
|
|
|
ERRCHK(dsa_acquisition_stop_acquire(acq));
|
|
|
}
|
|
|
|
|
|
void uploadTrace(DsaDevice dev, int traceIdx, int tableSize, double times[], double traces[], int traceConv) {
|
|
|
ERRCHK(dsa_acquisition_upload_trace(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, tableSize, times, traces, traceConv));
|
|
|
}
|
|
|
void uploadTrace(DsaDevice dev, int traceIdx, int tableSize, double times[], int traces[]) {
|
|
|
ERRCHK(dsa_acquisition_upload_inctrace(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, tableSize, times, traces));
|
|
|
}
|
|
|
|
|
|
void uploadInt32Trace(DsaDevice dev, int traceIdx, int tableSize, double times[], int traces[]) {
|
|
|
ERRCHK(dsa_acquisition_upload_int32_trace(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, tableSize, times, traces));
|
|
|
}
|
|
|
|
|
|
void uploadInt64Trace(DsaDevice dev, int traceIdx, int tableSize, double times[], eint64 traces[]) {
|
|
|
ERRCHK(dsa_acquisition_upload_int64_trace(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, tableSize, times, traces));
|
|
|
}
|
|
|
|
|
|
void uploadFloat32Trace(DsaDevice dev, int traceIdx, int tableSize, double times[], float traces[]) {
|
|
|
ERRCHK(dsa_acquisition_upload_float32_trace(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, tableSize, times, traces));
|
|
|
}
|
|
|
|
|
|
void uploadFloat64Trace(DsaDevice dev, int traceIdx, int tableSize, double times[], double traces[]) {
|
|
|
ERRCHK(dsa_acquisition_upload_float64_trace(acq, (DSA_DEVICE*)(dev.getDsaStructure()), traceIdx, tableSize, times, traces));
|
|
|
}
|
|
|
|
|
|
void getTimeLimits(double *startTime, double *endTime) {
|
|
|
ERRCHK(dsa_acquisition_get_time_limits(acq, startTime, endTime));
|
|
|
}
|
|
|
|
|
|
void reserve() {
|
|
|
ERRCHK(dsa_acquisition_reserve(acq));
|
|
|
}
|
|
|
|
|
|
void unreserve() {
|
|
|
ERRCHK(dsa_acquisition_unreserve(acq));
|
|
|
}
|
|
|
|
|
|
void setName(char *name) {
|
|
|
ERRCHK(dsa_acquisition_set_name(acq, name));
|
|
|
}
|
|
|
|
|
|
void unreserveAll(char *name) {
|
|
|
ERRCHK(dsa_acquisition_unreserve_all(name));
|
|
|
}
|
|
|
|
|
|
bool isReserved() {
|
|
|
bool reserved;
|
|
|
ERRCHK(dsa_acquisition_is_reserved(acq, &reserved));
|
|
|
return reserved;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
* DsaRTVSlot class - C++
|
|
|
*-----------------------------------------------------------------------------*/
|
|
|
class DsaRTVSlot {
|
|
|
protected:
|
|
|
DSA_RTV_SLOT *slot;
|
|
|
int typ;
|
|
|
/* constructors */
|
|
|
public:
|
|
|
DsaRTVSlot(DsaDsmax ultimet, int slotTyp) {
|
|
|
slot = NULL;
|
|
|
typ = slotTyp;
|
|
|
if (typ == SLOT_32BIT)
|
|
|
ERRCHK(dsa_get_32bit_rtv0_slot((DSA_DSMAX*)(ultimet.getDsaStructure()), &slot));
|
|
|
else if (typ == SLOT_64BIT)
|
|
|
ERRCHK(dsa_get_64bit_rtv0_slot((DSA_DSMAX*)(ultimet.getDsaStructure()), &slot));
|
|
|
else
|
|
|
ERRCHK(DSA_EBADPARAM);
|
|
|
}
|
|
|
DsaRTVSlot(DsaDsmax ultimet, int slotTyp, int lsl) {
|
|
|
slot = NULL;
|
|
|
typ = slotTyp;
|
|
|
if (typ == SLOT_32BIT)
|
|
|
ERRCHK(dsa_get_32bit_rtv1_slot((DSA_DSMAX*)(ultimet.getDsaStructure()), &slot, lsl));
|
|
|
else
|
|
|
ERRCHK(DSA_EBADPARAM);
|
|
|
}
|
|
|
DsaRTVSlot(DsaDsmax ultimet, int slotTyp, int lsl, int msl) {
|
|
|
slot = NULL;
|
|
|
typ = slotTyp;
|
|
|
if (typ == SLOT_64BIT)
|
|
|
ERRCHK(dsa_get_64bit_rtv1_slot((DSA_DSMAX*)(ultimet.getDsaStructure()), &slot, lsl, msl));
|
|
|
else
|
|
|
ERRCHK(DSA_EBADPARAM);
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
~DsaRTVSlot(void) {
|
|
|
if (slot)
|
|
|
if (typ == SLOT_32BIT)
|
|
|
ERRCHK(dsa_free_32bit_rtv_slot(&slot));
|
|
|
else if (typ == SLOT_64BIT)
|
|
|
ERRCHK(dsa_free_64bit_rtv_slot(&slot));
|
|
|
else
|
|
|
ERRCHK(DSA_EBADPARAM);
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
/*
|
|
|
* RTV_SLOT typ
|
|
|
*/
|
|
|
enum {SLOT_32BIT = 0}; /*32 bits slot */
|
|
|
enum {SLOT_64BIT = 1}; /*64 bits slot */
|
|
|
|
|
|
public:
|
|
|
void assignSlotToRegister(DsaDeviceBase grp, int typ, int idx, int sidx, int timeout) {
|
|
|
ERRCHK(dsa_assign_slot_to_register_s(grp.getDsaStructure(), slot, typ, idx, sidx, timeout));
|
|
|
}
|
|
|
void assignSlotToRegister(DsaDeviceBase grp, int typ, int idx, int sidx, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_assign_slot_to_register_a(grp.getDsaStructure(), slot, typ, idx, sidx, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void unassignSlotToRegister(DsaDeviceBase grp, int typ, int idx, int sidx, int timeout) {
|
|
|
ERRCHK(dsa_unassign_slot_to_register_s(grp.getDsaStructure(), slot, typ, idx, sidx, timeout));
|
|
|
}
|
|
|
void unassignSlotToRegister(DsaDeviceBase grp, int typ, int idx, int sidx, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_unassign_slot_to_register_a(grp.getDsaStructure(), slot, typ, idx, sidx, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void assignRegisterToSlot(DsaDevice dev, int typ, int idx, int sidx, int timeout) {
|
|
|
ERRCHK(dsa_assign_register_to_slot_s(dev.getDsaStructure(), typ, idx, sidx, slot, timeout));
|
|
|
}
|
|
|
void assignRegisterToSlot(DsaDevice dev, int typ, int idx, int sidx, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_assign_register_to_slot_a(dev.getDsaStructure(), typ, idx, sidx, slot, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
void unassignRegisterToSlot(DsaDevice dev, int typ, int idx, int sidx, int timeout) {
|
|
|
ERRCHK(dsa_unassign_register_to_slot_s(dev.getDsaStructure(), typ, idx, sidx, slot, timeout));
|
|
|
}
|
|
|
void unassignRegisterToSlot(DsaDevice dev, int typ, int idx, int sidx, DsaHandler handler, void *param = NULL) {
|
|
|
ERRCHK(dsa_unassign_register_to_slot_a(dev.getDsaStructure(), typ, idx, sidx, slot, (DSA_HANDLER)handler, param));
|
|
|
}
|
|
|
bool is32bit() {
|
|
|
return dsa_is_32bit_rtv_slot(slot);
|
|
|
}
|
|
|
bool is64bit() {
|
|
|
return dsa_is_64bit_rtv_slot(slot);
|
|
|
}
|
|
|
void read32bit(dword *value) {
|
|
|
ERRCHK(dsa_read_32bit_rtv_slot(slot, value));
|
|
|
}
|
|
|
void read64bit(dword *lvalue, dword *mvalue) {
|
|
|
ERRCHK(dsa_read_64bit_rtv_slot(slot, lvalue, mvalue));
|
|
|
}
|
|
|
void write32bit(dword value) {
|
|
|
ERRCHK(dsa_write_32bit_rtv_slot(slot, value));
|
|
|
}
|
|
|
void write64bit(dword lvalue, dword mvalue) {
|
|
|
ERRCHK(dsa_write_64bit_rtv_slot(slot, lvalue, mvalue));
|
|
|
}
|
|
|
void getSlotNr32bit(int *lsl) {
|
|
|
ERRCHK(dsa_get_32bit_rtv_slot_nr(slot, lsl));
|
|
|
}
|
|
|
void getSlotNr64bit(int *lsl, int *msl) {
|
|
|
ERRCHK(dsa_get_64bit_rtv_slot_nr(slot, lsl, msl));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/*
|
|
|
* this function should be defined once all classes are well known
|
|
|
*/
|
|
|
inline DsaDeviceBase Dsa::createAuto(EtbBus etb, int axis) {
|
|
|
DsaDeviceBase obj;
|
|
|
ERRCHK(dsa_create_auto_e(&obj.dsa, *(ETB **)&etb, axis));
|
|
|
return obj;
|
|
|
}
|
|
|
inline DsaDeviceBase Dsa::etcomCreateAuto(EtbBus etb, int axis) {
|
|
|
DsaDeviceBase obj;
|
|
|
ERRCHK(dsa_etcom_create_auto_e(&obj.dsa, *(ETB **)&etb, axis));
|
|
|
return obj;
|
|
|
}
|
|
|
inline DsaDeviceBase Dsa::createAuto(int prod) {
|
|
|
DsaDeviceBase obj;
|
|
|
ERRCHK(dsa_create_auto_o(&obj.dsa, prod));
|
|
|
return obj;
|
|
|
}
|
|
|
inline DsaDsmax DsaBase::getDsmax(void) {
|
|
|
DsaDsmax obj;
|
|
|
ERRCHK(dsa_get_dsmax(dsa, &obj.dsa));
|
|
|
ERRCHK(dsa_share(obj.dsa));
|
|
|
return obj;
|
|
|
}
|
|
|
inline void DsaBase::setDsmax(DsaDsmax dsmax) {
|
|
|
ERRCHK(dsa_set_dsmax(dsa, dsmax.dsa));
|
|
|
}
|
|
|
|
|
|
#undef ERRCHK
|
|
|
#endif /* DSA_OO_API */
|
|
|
|
|
|
|
|
|
#endif /* _DSA30_H */
|