XMC Motion Control
`XMCSPI Reference
`
`Revision:
`Author:
`Date:
`Description:
`
`Third Draft
`Dave Brown
`Wednesday. Feb 22. 1995
`This document is the XMCAPI reference describing all functions. standard OLE interfaces. and
`custom OLE interfaces making up the XMCAPI.
`
`Revision History:
`
`4/15/94 (DB)
`7/1/94 (DB)
`2/22/95 (DB)
`
`initial writing.
`- First Draft:
`- Second Draft: Split design off small business plan. incorporated suggestions.
`— Third Draft - Spiit XMCAPI reference off design guide,
`
`ROY—G-BIV Corporation Confidential
`© 1995 ROY-G-BIV Corporation. Au rights reserved.
`
`ROY—G—BIV CORPORATION
`
`EXHIBIT 2010-4
`
`ABB V ROY—G—B|V
`
`TRIAL |PR2013—00O62
`
`
`
`1
`
`

`
`
`
`XIIC Motion Control XMCSPI Reference Appendix A
`
`Appendix A
`
`A. 1 Reviewer Feedback
`
`All feedback is important in order to evolve the specification into a standard software model for
`motion control hardware. Please, at a minimum, respond to the following issues:
`
`5-".‘>.“!~'.-‘
`
`Which areas, ideas, or concepts within the specification seem confiising to you?
`Are there any main features missing from the specification that you would find useful?
`Are there any specific scenario-maps you would like to see in the next revision?
`Are there any specific C or C++ code examples you would like to see‘?
`Are there any specific Visual Basic code examples you would like to see?
`
`A.1.l Correspondence
`
`If possible, please send all feedback over email to the following address:
`
`Dave Brown
`
`ROY-G-BIV Corporation
`Compuserve:72 1023,2235
`Internet:
`72103.2235@compuserve.com
`
`Otherwise, if you do not have access to email, please mail all correspondence to the following
`address:
`
`Dave Brown
`
`ROY-G-BIV Corporation
`P.O. Box 1278
`
`White Salmon, WA. 98672
`
`
`ROY-G-BIV Corporation Confidential
`311 5195
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`2
`
`2
`
`

`
`XMC Motion control XMCSPI Reference
`
`3.0 XMCSPI Reference
`
`3.4.4 IXMC_DrvExtCG_ProgramMgmt Interface
`The [XMC_DrvExtCG_ProgramFlow interface is used to generate program flow code. Loops and
`if/then statements are several examples of contitional code generated. The following methods are
`in the interface:
`
`Programming
`(*pDrvExtCG_ProgMgmt) —>Run ()
`(*pDrvExtCG_ProgMgmt:) ->Stop ()
`
`Output
`(*pDrvExtCG_ProgMgmt) —>E.nableOutput ()
`('pDrvE:xtCG_ProgMgmt) —>SetOutput ()
`
`3.4.5 IXMC_DrvExtCG_Subroutine Interface
`
`The IXMC_DrvExtCG__Subroutine interface is used to generate subroutines and calls to
`subroutines. The following methods are in the lXMC__DrvExtCG_Subroutine interface:
`
`General
`(*pDrvExtCG_Sub) ->Define ()
`('pDrvExtCG_Sub) ->Call ()
`(*pDrvExtCG_Su.b) —>E.nd ()
`
`3.4.6 IXMC_DrvExtCG_Variable Interface
`The IXMC_DrvExtCG_Variable interface is used to define and assign values to variables. The
`following methods are included in the interface:
`
`Definition
`('pDrvE‘.xtCG_Var) ->Define ()
`
`Assignment
`T’
`(*pDrvExtCG_Var) —>AssignNumeric ()
`('pDrvExtCG_Var)->AssignBinary()
`(*pDrvExtCG_Var)->AssignString()
`
`
`ROY-G-BIV Corpomtion Confidential
`3115195
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`3
`
`3
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`Trigonometric
`('pDrvExtCG_Op)->ACos()
`('pDrvExtCG_Op)->ASin()
`(*pDrvExtCG Op)—>ATan()
`('pDrvExtCG:Op)->Cos(}
`('pDrvExtCG_Op)->Sin()
`(*pDrvExtCG_Op)—>Tan()
`
`Labelslstringslcornments
`('pDrvExtCG_Op)->ASCIICha:(J
`('pDrvExtCG_Op)->Comentt)
`(*pDrvExtCG_Op)—>DeclarLabel()
`('pDrvExtCG_Op)->String()
`
`Conditional
`(*pDrvExtCG_Op)->Equal()
`('pDrvExtCG_Op)—>GreaterThan()
`(*pDrvExtCG_Op)->GreaterThanEqual()
`(*pDrvExtCG_Op)—>LessThan()
`(*pDrvExtCG_Op)->LessThanEqual()
`('pDrvExtCG_Op)->NotEqual()
`
`3.4.2 IXMC_DrvExtCG_Program Interface
`
`The IXMC_DrvExtCG_Program interface is used to generate a progmm shell using the
`appropriate vendor-specific control-codes. The following methods are in the interface:
`
`Programmming
`(*pDrvExtCG_Prog)—>Define()
`(*pDrvExtCG_Prog)—>End()
`(*pDrvExtCG_Prog)->Exit()
`(*pDrvExtCG_Prog)->Sleep()
`
`3.4.3 IXMC_DrvExtCG__ProgramFlow Interface
`
`The lXMC_DrvExtCG_ProgramF low interface is used to generate program flow code. Loops and
`if/then statements are several examples of contitional code generated. The following methods are
`in the interface:
`
`lfIElse
`('pDrvExtCG_ProgFlow)—>IfOpen()
`('pDrvExtCG_ProgFlow)->IfClose()
`('pDrvExtCG_ProgFlow)—>Else()
`('pDrvExtCG_ProgF1ow)->EndIf()
`
`VVhfle
`('pDrvExtCG_ProgFlow)->WhileOpen()
`('pDrvExtCG_ProgFlow)->WhileClose()
`(*pDrvExtCG_ProgFlow)—>EndWhile()
`
`Repeat
`('pDrvExtCG_ProgFlow)—>Repeat()
`('pDrvExtCG_P:ogFlow;->UntilOpen()
`('pDrvExtCG_ProgFlow)—>Un:ilClose(L
`
`Loops
`('pDrvExtCG_ProgFlow)->Loop(l
`('pDrvExtCG_ProgFlow)->EndLoop()
`
`Nfisc.
`(*PDrvExtCG_ProgFlow)->Break()
`('PDrvExtCG_ProgFlow;->GoTo()
`
`_______————__________________________________________________________________—_——
`ROY-G-BIV Corporation Confidential
`3115195
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`4
`
`4
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`3.3.6 IXMC_DrvExtUI_DigitalIO Interface
`
`The IXMC_DrvExtUl_Digitall0 interface allows the user to interactively view and set the
`parameters used when initializing the digital IO system.
`
`Inheritance
`IXMC_DrvExtUI_Base
`
`l I
`
`———— —— IXMC DrvEx:UI Dicitallc
`
`3.3.7 IXMC__DrvExtUI_Servo Interface
`
`The IXMC_DrvExtUI_Servo interface allows the user to interactively view and set the servo
`system parameters. Also, the interface allows the user to interactively tune the PID settings used.
`
`Inheritance
`IXMC_DrvExtUI_Base
`
`I I
`
`———— —-
`
`IXMC_DrvExtUI_Se:vo
`
`Configuration
`("pDrvE.xt_Motion) —>Tune ()
`
`3.4 XMC Extended Code Generation Interfaces (ExtCG)
`
`Code generation interfaces are used by the Motion Control Component to generate the appropriate
`vendor-specific control-codes used to create a motion control program. Unlike other interface
`supported by each Motion Control Driver, the code-generation interfaces are never used in real-
`time mode.
`
`NOTE: Currently, the implementations of all code generation interfaces are a direct mapping of the Motion
`Control Component code generation interfaces and are under investigation.
`
`3.4.1 IXMC_DrvExtCG_Operator Interface
`The lXMC_DrvExtCG_Operator interface is used to generate general program code such as
`boolean, logical, simple conditional, and mathematical operators. The following methods are in
`the interface:
`
`Bitwise
`('pDrvExtCG_Op)—>BitAnd()
`('pDrvExtCG_Op)->BitNot()
`('pDrvExtCG_Op) ->BitOr ()
`("pDrvExtCG_Op) —>BitShiftL ()
`(*pDrvExtCG_Op)->BitShiftR()
`('pDrvExtCG_Op)->BitXOr()
`
`Logical
`(*pDrvExt:CG_Op) ~>And ()
`('pDrvExtCG_Op)->Not()
`('pDrvExtCG_Op) —>Or ()
`
`Mathematical
`('pDrvExtCG_Op)->Add()
`('pDrvExtCG_Op)->Bi:(
`('pD:vExtCG_Op)->Div()
`('pDrvExtCG_Op)—>LeftParen()
`('pDrvExtCG_Op)->Mul:()
`('pDrvExtCG_Op)->Ri9htParen()
`(‘pDrvExtCG_Op)->Sqrt()
`('pDrv£xtCG_Op)->Sub()
`
`
`ROY-G-BIV Corporation Confidential
`3115195
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`5
`
`5
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`3.3 XMC Extended UI Interfaces (ExtUI)
`All extended Ul custom OLE 2.0 interfaces use user-interface resources such as dialog boxes or
`windows to interact with the user. Some interfaces may gather information from the user. where
`others may just display information.
`
`3.3.1 IXMC_DrvExtUI_AnalogIO Interface
`
`The IXMC_DrvE.xtUI_AnalogIO interface allows the user to interactively view and set the
`parameters used when initializing the analog IO system.
`
`Inheritance
`
`IXMC_DrvCore_IO
`
`I l
`
`---- -— IXMC_DrvCore_Dic_:i:alIO
`
`3.3.2 IXMC_DrvExtUI_AnalogIO Interface
`
`The IXMC_DrvExtUI_Analog_IO interface allows the user to interactively view and set the
`parameters used when initializing the analog IO system.
`
`Inheritance
`IXMC_DrvE.xtUI__Base
`
`I |
`
`---- -- IXMC_DrvExtUI_AnalogIO
`
`3.3.3 I_XMC_DrvExtUI_Base Interface
`
`The IXMC_DrvExtUI_Base interface is an abstract base derived off by all other Extened UI
`interfaces. The two methods defined in this interface, implemented by the deriving interface, are
`used to initialize and view data.
`
`_C_onfiguration
`(*pDrvExtUI_Base) ->In1tialize ()
`('pDrvE‘.xtUI_Base> —>\/iew ()
`
`3.3.4 IXMC__DrvExtUI_DynamicState Interface
`
`The IXMC_DrvExtUI__DynamicState interface allows the user to interactively view and set all
`dynamic parameters used in the motion control system.
`
`Inheritance
`IXMC_DrvExtUI_Base
`
`l I
`
`---- -- IXMC_DrvExtUI_DynamicSta1:e
`
`3.3.5 IXMC_DrvExtUI_StaticState Interface
`
`The IXMC__DrvExtUI_StaticState interface allows the user to interactively view and set all
`static system parameters used when initializing the motion control system.
`
`Inheritance
`IXMC_D rvExtU I_Ba se
`
`l l
`
`---- -- IXMC_D:vExcUI Staticstate
`
`
`ROY-G-BIV Corporation Confidential
`3115/95
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`6
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`( pDrvExt_Motion;—>EnableFeedRate()
`( pD:vEx:_Mocion)—>EnableInte:polaticn()
`( pDrvExt_Motion)->EnableAxisScalingl)
`('pD:vExt_Motion)->EnablePathScaling()
`( pD:vExt_Motioni*>GoHome()
`( pDrvExt_Motion)->GoZero()
`( pD:vExt_Motion)->MoveRel()
`
`Geometric Moves
`(*pDrvExt_Motion)->Arc()
`('pDrvExt_Motion)—>Pach()
`
`3.2.11 IXMC_DrvExt_StaticState Interface
`
`The lXMC_DrvExt_StaticState interface manages all extended static state information defining
`the system. Like the current state information. the device context infonnation may be queried at
`any time after the system is initialized. But. unlike the current state information, the device
`context infonnation is only set during the initial setup of the system.
`
`State Information
`typedef struct _XMC_EXTSTATICSTATEINFO
`l
`
`——
`
`dwSupportedProperties:
`dfAxisScalingFactor:
`dfPathScalingFactor;
`dfMaxAcceleration;
`dfMaxDeceleration:
`dfMaxVelocity;
`
`DWORD
`double
`double
`double
`double
`double
`) XMC_EXTSTATICSTATEINFO;
`
`Querying Attributes
`(*pDrvCore_DC)->GetState()
`
`Setting Attributes
`('pDrvCore_DC)~>Se:Sta:e()
`
`3.2.12 IXMC_DrvExt_Timer Interface
`
`The lXMC_DrvExt_Timcr interface is used to manipulate a timer on the motion control
`hardware.
`
`Querying Attributes
`('pD:vExt_Timer)->GetTime()
`('pDrvExt_Timer)~>GetDelay()
`('pDrvExt_Timer)->GetResolution()
`
`Setting Attributes
`('pDrvExt_Timer)->Se:De1ay()
`
`Actions
`('pD:vExt_Time:)->DoDelay()
`('pDrvEx:_Timer)->EnableIn:er:upt()
`('pDrvEx:_Timer)->Rese:()
`('pDrvExt_Timerl—>Startl)
`('pDrvExt Timer)->Stop{)
`('pDrvExt:Timer)->T:icge:Inter:upt()
`
`
`ROY-G-BIV Corporation Confidential
`3115/95
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`7
`
`

`
`3.0 XMCSPI Reference XMC Motion Control XMCSPI Reference
`
`3.2.8 IXMC_DrvExt_Jo_vstick Interface
`
`The IXMC_DrvExt_Joystick interface is used to enable and disable a hardware joystick. When
`enabled. all other motion operations are disabled. The following methods are in this interface:
`
`Setting Attributes
`(*pDrvExt_Joys:ick)->SetVelocityHigh()
`(*pDrvExt_Joystick)->SetVelocityLow()
`(*pD:vEx:_Joys:ick)—>SetupElec::onics()
`
`Actions
`(*pDrvExt_Joystick)->Enable()
`
`3.2.9 IXMC_DrvExt_Limits Interface
`
`The IXMC__DrvExt_Limits interface is used to manipulate both hardware and software limits.
`The following methods are in this interface:
`
`Querying Attributes
`('pDrvExt_Limits)->GetSoftwareLimitPositions()
`
`Setting Attributes
`(*pDrvExt_Limits)->SetSoftwareLimitPositions()
`(*pDrvExt_Limits)->SetDeceleration()
`
`Actions
`(*pDrvExt Limits)—>EnableHardwareLimits()
`(*pDrvExt:Limits)->EnableSoftwareLimits()
`
`3.2.10 IXMC_DrvExt__Motion Interface
`This interface consists of extra motion control functions that may or may not be implemented by
`the motioilcontrol hardware. If a hardware implementation is unavailable for a particular
`function. the Motion Component calls the Motion Control Driver Stub, which implements the
`functionality in software. The following methods are available from either the Motion Control
`Driver or the Motion Control Driver Stub in the lXMC_DrvExt__MotionControl interface:
`
`Querying Attributes
`('pDrvExt_Motion)->GetFeedRate()
`('pDrvExt_Motion)->GecAxisScaling()
`('pDrvExt_Motion)—>GetPathScaling()
`(*pDrvExt_Motion)->GetMaxAcceleration()
`('pDrvEx:_Motion)—>GetMaxDeceleration()
`('pDrvExt_Motion)—>GetMaxVelocity()
`(*pDrvExt_Motion)~>GetHomePosi:ion()
`(*pDrvExt_Motion)->IsDataCaptureOn()
`(*pD:vExt_Motion)->IsFeedRateOn()
`('pDrvExt_Motion)—>IsAxisScalingOn()
`('pD:vExt_Motion)—>IsPathScalingOn()
`('pDrvExt_Motion)->IsInterpolationOn()
`
`Setting Attributes
`('pDrvEx:_Motion)->SetJogVelo:ityHigh(}
`('pDrvEx:_Motion)—>SecJogvelocityLow()
`('pD:vExt_Mocicn)->SecFeedRatei)
`('pD:vExt_Motion)->SetAxisScaling()
`('pDrvEx:_Mocion)—>SetPathScaling()
`('pDrvExt_Motion)—>Se:MaxAcceleration()
`('pD:vExt_Motion)->SetMaxDecele:ation()
`(*pDrvExt_Motion)->SetMaxVelocity()
`('pDrvExt_Mo:ion)->SetZeroPosi:ion()
`('pDrVEXt_MOtiOn)->SetHomePosi:ion()
`
`ROY-G-BIV Corporation Confidential
`3115195
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`A 8
`
`8
`
`

`
`XMC Motion Control XMCSPI Reference
`
`3.0 XMCSPI Reference
`
`3.2.4 IXMC_DrvExt_DigitalIO Interface
`
`The [XMC__DrvExt_Digita|I0 interface handles all extended l0 functional_v.
`
`Actions
`('pDrvEx:_Dig; a2 110)—>EnableInputFunctions()
`('pDrvEx:_Dig‘ta1IO )->EnableOutputFunctions()
`
`Setting Attributes
`('pDrvExt_DigitalIO)->SetInputFunCtion()
`(*pDrvExt_DigitalIO)->SetInputDebounceTime()
`(*pDrvExt_DigitalIO)->SetInputActiveLevel()
`('pDrvExt_DigitalIO)—>SetOu:putFunction()
`(*pD:vEx:_DigitalIO)—>SetOutputActiveLevel()
`(*pD:vEx:_Digi:alZO)->SetOutputStates()
`
`3.2.5 IXMC_DrvExt_Encoder Interface
`
`The IXMC_DrvExt_Encoder interface is used to manipulate encoders in the motion control
`system.
`
`Setting Attributes
`('pDrvExt_Encode:)->SetOutputAbsPosition()
`(*pDrvExt_Encoder)->SetOutputRelPosition()
`
`—
`
`3.2.6 IXMC_DrvExt_Interrupt Interface
`The [XMC_DrvExt_Interrupt interface is used to set, get, and enable interrupt handlers
`
`Querying Attributes
`(*pDrvExt_Int)->GetHand1er()
`
`Setting Attributes
`(*pDrvExt_Int)->SetHandler()
`
`Actions
`(*pDrvExt_1nt)->Enab1e()
`
`3.2.7 IXMC_DrvExt_IO Interface
`This interface consists of all digital input and output related functions. The following methods are
`available from each Motion Control Driver in the lXMC_DrvExt_Digitall0 interface:
`
`Actions
`('pDrvExt_IO)->EnableDacaCapture();
`
`
`
`ROY~G-BIV Corporation Confidential
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`9
`
`3/15/95
`
`9
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`3.2.2 IXMC_DrvExt_Debug Interface (Private)
`
`The IXMC_DrvExt__Debug interface is a private interface used by the Motion Control
`Component, if available. When implemented, the interface is used when debugging the Motion
`Control Driver.
`
`Setting Attributes
`('pDrvExt_Debug)->SetRawDataInDumpFile()
`(*pDrvExt_Debug)->SetRawDataOutDumpFile()
`(*pDrv£xt_Debug)->SetXMCSPILogFi1e()
`
`Actions
`('pDrvExt_Debug)->Enab1eRawDataDump()
`(*pDrvExt_Debug)->EnableXMCSPILogging()
`
`3.2.3 IXMC_DrvExt_D_vnamicState Interface
`The [XMC_DrvExt__DynamicState interface manages the extended, dynamic state of the motion
`control system. The extended current state information may be queried or changed at any time
`after the system is initialized.
`
`State Information
`typedef struct _XMC_EXTDYNAMICSTATEINFO
`l
`
`dwSupportedPoperties;
`'pExtXMCDC:
`dfLimitDeceleration:
`dfJogVelocityHigh;
`dfJogVelocityLow:
`dfJoystickVelocityHigh;
`dfJoystickVelocityLow;
`dfFeedRate;
`*pHomePosition:
`'pZeroPosition:
`'pLimitSWFwdPosition;
`*pLimitSWBwdPosition;
`dfLimitDeceleration;
`bJoystick:
`bAxisScaling;
`bPathscaling;
`bDataCapture;
`bFeedRate;
`blnterpolation;
`bLimitSW;
`bLimitHW:
`bIODataCapture;
`
`__
`
`DWORD
`XMC_EXTSTATICSTATEINFO
`double
`double
`double
`double
`double
`double
`POs_DATA
`POS_DATA
`POS_DATA
`POS_DATA
`double
`BOOL
`BOOL
`BOOL
`BOOL
`EOOL
`BOOL
`BOOL
`BOOL
`BOOL
`) XMC_EXTDYNAMICSTATEINFO:
`
`Querying Attributes
`('pDrvCore_DynSt)->GetState()
`
`Setting Attributes
`('pDrvCore_DynSt)->SetState(}
`
` :jj
`
`ROY-G-BIV Corporation Confidential
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`10
`
`3/1 5195
`
`10
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`3.1.10 IXMC_DrvCore_StaticState Interface
`
`The IXMC_DrvCore_StaticState interface manages all static state infonnation defining the
`system. Like the current state infonnation, the device context infonnation may be queried at any
`time after the system is initialized. But. unlike the current state information. the device context
`information is only set during the initial setup of the system.
`
`State Infonnation
`typecie 5 s trust _XMC_S-'I‘.I{Z‘ I CSTATE INFO
`(
`
`dfEncode:CountsPerRevolution;
`double
`dfMMPerRevolucion.'
`double
`cbAxisCoun::
`int
`cbAxi sMax;
`int
`XMCMOTORTYPE
`moto:Type;
`) XMC_STATICSTATEINFO;
`
`Querying Attributes
`('pDrvCore__StatSt) ->GetState ()
`
`Setting Attributes
`(*pDrvCore_StatSt) ->SetStat:e()
`
`__
`
`3.1.11 IXMC_DrvCore_Stepper Interface
`The IXMC_DrvCore_Stepper interface handles all operations specific to stepper motors. All
`motion operations are performed by the IXMC_DrvCore_Motion interface. The following
`methods are in the IXMC_DrvCore_Stepper interface:
`
`Dependency
`IXMC_DrvCore_Motion
`
`I I
`
`----— IXMC_DrvCore_St:epper
`
`Configuration
`('pDrvCore_Stepper) ->Initialize ()
`
`3.2 XMC Extended Interfaces (Ext)
`Extended interfaces contain methods that are not required. These interfaces are either duplicated
`by the Motion Control Driver Stub or contain functionality not essential in most motion control
`problems. However, implementing these interfaces will optimize the performance of the motion
`control system for a particular set of hardware. This section describes all extended interfaces
`within XMCSPI.
`
`3.2.1 IXMC_DrvExt_Counter Interface
`
`The IXMC_DrvExt_Counter interface is used to operate a counter implemented by the motion
`control hardware.
`
`Querying Attributes
`('pDrvE‘.xt_Counter) ->GecCounter ()
`
`Actions
`('pDrvExt_Coum:er_) ->EnableIn1:errupt ()
`('pDrvExt_Counter)->Rese:()
`('pDrvEx:_Counter)->Start()
`('pDrvExt_Counter)->Stop()
`
`
`ROY-G-BIV Corporation Confidential
`SH 5195
`© 1995 ROY—G-BIV Corporation. All Rights Reserved.
`
`11
`
`11
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`3.1.8 IXMC_DrvCore_Motion Interface
`
`This IXMC_DrvCore_Motion interface is a dependant interface in that it may only be used after
`either the'lXMC_DrvCore_Stepper or lXMC_DrvCore_Servo interfaces are used to initialize
`the system. All primitive motion control functions that are absolutely necessary to solve motion
`control software problems are placed in this interface. Also, each function in this set should be a
`primitive that can not be duplicated through a software algorithm built on top of other primitive
`functions. The following methods are available fi'om each Motion Control Driver in the
`IXMC_DrvCore__MotionControl interface:
`
`Querying Attributes
`(*pDrvCore Motion} ->GetCommandedPosi’cion ()
`('pDrvCore:Mo'.: ion) —>Get:ActualPosit ion ( )
`('pDrvCore_Motion) ->Get:CommandedVelocity ()
`(*pDrvCore_Mot.ion) —>GetActualVelocity ()
`
`Setting Attributes
`('pDrvCore_Motion)~>setVelocity()
`('pDrvCore_Motion)->SetPosition()
`
`Actions
`("_DDrvCore_Motion) ->Kill ()
`(*pDrvCore_Motion) ->MoveAbs ()
`(*pDrvCore_Motion) —>MoveContinous ()
`("pDrvCore_Mot ion) ->Stop ( )
`
`3.1.9 IXMC_DrvCore__Servo Interface
`
`The lXMC_DrvCore_Servo interface handles all operations specific to servo motors. All motion
`operations are performed by the IXMC_DrvCore_Motion interface. The following methods are
`in the IXMC_DrvCore_Servo interface:
`
`Dependency
`IXMC_DrvCore_Mo:ion
`
`I l
`
`—— -- — IXMC_D rvco re__Servo
`
`Configuration
`('pDrvCore_Servo)~>Initiali2e()
`(*pDrvCore_Servo)->Tune()
`
`
`
`ROY-G-BIV Corporation Confidential
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`.
`
`3/15/95
`
`12
`
`12
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 3.0 XMCSPI Reference
`
`3.1.5 IXMC__DrvCore_EnumInterfaceSupport Interface
`
`The lXMC_DrvCore_Enumlnterfacesupport interface is used to query a list of interfaces
`meeting the specific search criteria set with the
`lXMC_DrvCore_Enumlmerfacesuppon::SetSearchCriteria0 method..
`
`Inheritance
`II-.‘.numX
`
`i |
`
`--- IXMC_DrvCore_E.numInterfacesupport
`
`Setting Attributes
`('pDrvCore__EnumIFace) ->Set:SearchCrite:ia ()
`
`3.1.6 IXMC_DrvCore_IO Interface
`This interface consists of all digital input and output related functions. The following methods are
`available from each Motion Control Driver in the lXMC_DrvCore_DigitalIO interface:
`
`Configuration
`('pDrvCore_IO) ->Initialize ()
`
`Actions
`('pDrvCore_I0) —>Read ()
`(*pDrvCore_IO) —>write ()
`
`3.1.7 IXMC_DrvCore_Limits Interface
`
`The IXMC_DrvCore_Limits interface is used to set software limits for a set of axes. When
`setting limit values, two arrays containing AX1S_DA TA elements are used to transfer the settings
`to the method.
`
`Setting Attributes
`('pDrvCore_Limits) ->SetLimitPositions ()
`
`NOTE: Currently, this interface is classified as a core set of XMCSPI, but it may be changed to an extended
`set of XMCSPI instead.
`
`
`ROY-G-BIV Corporation Confidential
`3/15/95
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`13
`
`13
`
`

`
`XMC Motion Control XMCSPI Reference
`
`3.0 XMCSPI Reference
`
`3.1.3 IXMC_DrvCore_DynamicState Interface
`
`The lXMC_DrvCore_DynamicState interface manages the overall state of the motion control
`system.
`lncluded in its management tasks are initializing and shutting down the system. The
`current state information may be queried or changed at any time after the system is initialized.
`
`State Information
`typedef scruc: _xMC_DYNAMIcsTATEINEo
`{
`
`XMC_STATICSTATE
`double
`double
`double
`double
`double
`double
`double
`HRESULT
`XMC_OP_MODE
`XMC_AXIS_DATA
`XMC_AXIS DATA
`} XMC_DYNAMf-CSTATEINFO;
`
`,
`
`'pXMCDC;
`dfAc:ualPosition;
`dfCommandedPosition;
`dfActualVelocity:
`dfcomandedvelocity;
`dfPositionError;
`dfAcceleration;
`dfDeceleration;
`hE::orStatus;
`opera:ingMode;
`'pLeftLimicData;
`'pRightLimitData;
`
`Configuration
`(*pDrvCore_DynSt)->Reset()
`('pDrvCore_DynSt)->Initialize()
`('pDrvCore_DynS:)->ShutDown()
`
`Querying Attributes
`(*pDrvCore_DynSt)->GetErrorStatus()
`(*pDrvCore_DynSt)->GetState()
`
`Setting Attributes
`('pDrvCore_DynSt)->ClearE:rors()
`('pDrvCore_DynSt)—>SetState()
`
`3.1.4 IXMC_DrvCore_Encoder Interface
`
`The IXMC_DrvCore_Encoder interface implements several optimized functions used to query
`positions. Calling the lXMC_DrvCore_D_vnamicState:.-Getstateo method will also collect the
`position information. but at the expense of collecting all other current state data. The methods
`specified by this interface only collect the data requested.
`
`Querying Attributes
`(*pDrvCore_Motion)—>GetPositionActual()
`('pDrvCore_Mo:ion)—>GetFosi:ionE:ror()
`
`NOTE: Currently, this interface is classified as a core set of XMCSPI. but it may be changed to an extended
`set of XMCSPI instead.
`
`
`ROY-G-BIV Corporation Confidential
`3/15/95
`© 1995 ROY-G-BIV Corporation. All Rights Reserved‘
`
`14
`
`14
`
`

`
`XMC Moflon control XMCSPI Reference
`
`3.0 XMCSPI Reference
`
`3.0 XMCSPI Reference
`
`3.1 XMC Core Interfaces (Core)
`Core functions are the lowest level primitive motion control functions implemented by all
`hardware vendors that software cannot duplicate in an algorithm that uses other methods, such as
`those in the Motion Control Driver Stub. This section describes each custom OLE 2.0 interface
`within the set of core interfaces.
`
`3.1.1 IXMC_DrvCore_AnalogIO Interface
`
`The IXMC_DrvCore_AnaloglO interface inherits from the IXMC_DrvCore_IO interface and
`implements all of its methods. This interface take care of initializing the analog I/O system used.
`All U0 work is carried out by the IXMC_DrvCore_IO interface.
`
`Inheritance
`IXMC_DrvCore_IO
`
`I I
`
`---- -- IXMC_DrvCore_AnalogIO
`
`Configuration
`('pDrvCore_AnalogIO)->Initialize()
`
`3.1.2 IXMC_DrvCore_DigitalIO Interface
`
`Similar to the IXMC_DrvCore_AnalogIO interface, the IXMC_DrvCore_DigitalIO interface is
`also inherits from the IXMC_DrvCore_IO interface. The IXMC_DrvCore_DigitallO interface
`takes care of initializing the digital I/O system, and the IXMC_DrvCore_IO interface takes care
`of all other operations.
`
`Inheritance
`IXMC_DrvCore_IO
`
`l I
`
`---- -- IXMC_D:vCore_DigitalIO
`
`Configuration
`(*pDrvCore_Digi:alIOl—>Initialize()
`
`
`
`ROY-G-BIV Corporation Confidential
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`15
`
`3115195
`
`15
`
`

`
`XMC Motion control XMCSPI Reference
`
`2.0 XMCSPI Interface Categories
`
`
`
`Operator
`Program
`Program}-' low
`ProgmmMgmt
`Subroutine
`Variable
`
`‘ These interfaces generate code implicitly. Calling methods, that immediately cause an action on
`the hardware when run in real-tirne mode, generate code when run in code-generation mode.
`
`2.6 Interface Relationships
`This section describes how closely coupled XMCSPI interfaces relate to one another. There are
`two ways interfaces relate to one another.
`Interfaces can inherit from each other and can be
`dependent on one another. The following sections describe these relationships and the interfaces
`using them.
`
`2.6.1 Inheritance Relationships
`C++ inheritance is used to combine two interfaces in such a way that the derived interface
`“inherits” all method definitions in the base interface. Only the method definitions within the base
`interface are inherited. The resulting interface contains implementations of all methods in both
`the derived and the base interface. The following are the inheritance relationships found in the
`XMCSPI:
`
`Inheritance Tree
`IXMC_DrvCore_IO
`
`I |
`
`—-— IXMC_DrvCore_DigitalIO
`|--- IXMC_DrvCore_AnalogIO
`
`IXMC_DrvExtUI_Base
`
`I l
`
`--- IXMC_DrvExtUI Analoglo
`|--— IXMC_DrvExtUI:DigitalIO
`|——-
`IXMC DrvExtUI Dynamicstate
`l——-
`IXMC:DrvExtUI:Servo
`|--- IXMC_DrvExtUI_StaticState
`
`2.6.2 Dependency Relationships
`
`Unlike inheritance relationships. dependency relationships are between two interface
`implementations. When an interface is dependent on another interface, it needs the interface to
`perform an operation before it can continue one of its own operations. For example. the
`IXMC_DrvCore_Motion interface is dependent on the lXMC_DrvCore_Stepper interface
`initialization routine. Before using the IXMC_DrvCore_Motion interface, the
`lXMC_DrvCore_Stepper interface must be used to initialize the stepper system. The following
`are the dependency relationships found in the XMCSPI:
`
`Dependency Tree
`IXMC_DrvCore_Motion --I
`IXMC_DrvE.v.:_Mo:ion ———!
`
`2-:
`
`(dependent on)
`3
`V
`E——— lXMC_DrvCore_Stepper
`i-—- ZXMC_D:vCore_Se:vo
`
`__j__j
`ROY-G-BIV Corporation Confidential
`3/15/95
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`16
`
`16
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 2.0 XMCSPI Interface Categories
`
`The following custom OLE 2.0 interfaces are in the set of code-generation XMCSPI functions:
`
`Custom ExtCG Interfaces
`IXMC DrvExt:CG_ProgramF.-‘low
`IXMC:DrvExtCG_Ope rat 0:
`IXMC_DrvExtCG__P:ogram
`IXMC_DrvExtCG_Prog ::a.mMgmt
`IXMC_DrvExtCG_Subroutine
`IXMC_DrvExtCG__Va ri able
`
`2.4 Vendor Specific Interfaces (ExtVS)
`These functions are not part of the set of XMCSPI interfaces. No XMCAPI interface methods call
`these functions for they are provided by each vendor as a pass-through method giving vendors
`access to new hardware features not yet supported by the XMC software model. Each
`implementation of vendor specific custom OLE interfaces depend on the needs of the hardware
`vendor. Applications may communicate directly with these interfaces, but in doing so, they
`automatically become dependent on the specific Motion Control Driver and therefore become
`hardware-dependent. But, allowing vendor-specific functions to exist gives the software model a
`flexible way to evolve. For example, if one hardware vendor adds a new feature to their motion
`control hardware, not provided by any other vendors, they may gain access to the new feature by
`adding a vendor specific SPI interface to their driver and then directly programming to the SP1
`interface from within the application. Of course, other drivers will not work with applications that
`call the hardware dependent SP1 interface, for they will not implement the interface. As the
`feature becomes more useful over time, other hardware vendors will probably add the feature to
`their hardware. After the feature gains a critical mass of support within the companies supporting
`the XMC sofiware model, the feature will be added to the XMC software model by becoming a
`part of both the XMCSPI and XMCAPI. For more information on vendor specific interfaces, see
`the appropriate XMC Motion Conu*ol Extension manual describing the specific XMC Driver
`which includes a reference for each hardware-dependent driver interface.
`
`2.5 Interface Map
`The following table displays all Motion Control Driver, XMCSPI interfaces and the categories
`they fall in:
`
`Core
`“IXMCDrvCore_”
`
`Ext
`“IXMCDrvExt_”
`
`ExtUI
`“lXMCDrvExtUI_”
`
`ExtCG
`“IXMCDrvExtCG_”
`
`AnalogIO
`AnaloglO
`AnaloglO“
`Base
`
`Counter
`Counter‘
`
`Debug (Private)
`’ DigitalIO
`DigitalIO
`"" Digitallo
`Digitallo‘
`’""""”’"’
`
`Dynamicstate
`Dynamicstate
`Dynarnicstate
`Encoder
`Encoder
`Enumlnterface
`
`Encoder‘
`
`Interrupt i_""_““" '“"
`
`[0 (Abstract)
`10 (Abstract)
`IO‘
`Joystick
`Joystick‘
`Limits
`Limits
`Limits‘
` T&fiYXB§':?§é?jiW—"-%_——_T4*ciB}i‘7‘—-'*“_”
`
`Servo
`Servo
`Servo
`Servo‘
`Staticstate
`Staticstate
`Staticstate
`
`'
`
`Stepper
`
`’"
`
`Timer
`
`__
`
`"W
`
`__________V_
`
`Stepper‘
`“’——‘_—__‘—Ti}i'{Er”-""'""’""""""""'i'
`
`
`311 5195
`ROY-G-BIV Corporation Confidential
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`17
`
`17
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 2.0 XMCSPI Interface Categories
`
`current driver. that can be emulated using a software algorithm which calls core fimctions. For
`more information on how the XMC Driver Stub is used. see Section 7.0 Driver Administrator.
`
`Component, Driver Relationship in the XMC User Guide manual. Implementing extended
`interfaces directly in the driver can improve the precision and efficiency of the operation, for the
`driver implementation has more direct control over the motion control hardware than the XMC
`Motion Control Component. Even greater precision and performance improvements occur when
`the driver can direct the motion control hardware to directly perform a procedure defined in one of
`the extended interfaces.
`
`2.3.1 Extended Interfaces (Ext)
`
`This set of functions consists of all non core functions that do not use user-interface objects such
`as dialog boxes or message boxes. The following custom OLE 2.0 interfaces are in the set of
`extended XMCSPI functions:
`
`Custom Ext Interfaces
`IXMC_DrvExt_Counte:
`IXMC_DrvExt_Debug (Private)
`IXMC_DrvExt_DynamicState
`IXMC_DrvExt_Encode:
`IXMC_DrvExt_Interrupt
`IXMC_DrvExt_IO (Abstract)
`IXMC_DrvExt_Joystick
`IXMC_DrvExt_Limits
`IXMC_DrvExt_Motion (Dependent)
`IXMC DrvExt Staticstate
`
`IXMC:DrvE2xt::’I‘imer
`
`2.3.2 Extended UI Interfaces (ExtUI)
`
`_
`
`This XMCSPI set consists of all extended XMCSPI functions that require user-interface objects
`such as dialog boxes or message boxes. For example, when an application requests to tune the
`servo mo_t—ors, special input may be needed from the user to complete the process. Because tuning
`the servo motors is not a required motion control function and may need input from the user, it is
`in the Extended UI XMCSPI set of functions.
`
`The following custom OLE 2.0 interfaces are in the extended user-interface set of XMCSPI
`functions:
`
`Custom Extul interfaces
`IXMC_DrvExtUI_AnalogIO
`IXMC_DrvExtUI_Base
`IXMC_DrvExtUI_DigitalIO
`IXMC_DrvExtUI_DynamicState
`IXMC_DrvExtUI_Servo
`IXMC_DrvExtUI_Staticstate
`
`2.3.3 Extended Code Generation Interfaces (ExtCG)
`
`These XMCSPI functions consist of all methods used for code generation only. Most core and
`extended methods generate code also generate code when the XMC software is run in code-
`generation mode. But. where core and extended functions may also be used in real-time and
`mixed modes. code-generation functions cannot. Code-generation functions are only used when
`running in code-generation mode.
`
`
`ROY-G-BIV Corporation Confidential
`‘
`3115/95
`© 1995 ROY-G-BIV Corporation. All Rights Reserved.
`
`18
`
`18
`
`

`
`
`
`XMC Motion Control XMCSPI Reference 2.0 XMCSPI Interface Categories
`
`2.0 XMCSPI Interface Categories
`This section describes the categorical grouping of the OLE interfaces found in the XMCSPI. Both
`standard and custom OLE interfaces are used in the XMCSPI. OLE 2.0 requires the
`
`implementation of all interfaces listed in Section 2.] Standard OLE Interfaces. XMC requires the
`implementation of all interfaces listed in section 2. I Care Interfaces.
`
`2.1 Standard OLE Interfaces
`
`The following standard OLE interfaces must be supported by each Motion Control Driver. For
`more information on each interface. see section 2.0 Standard OLE Interfaces in the XMCAPI
`Reference manual.
`
`Standard Interfaces
`IClassEactory
`IUnknown
`
`2.2 Core Interfaces (Core)
`
`Any absolutely essential functions to motion control problems are in the core set of functions. All
`motion control XMCSPI drivers must implement these core functions. None of these functions
`are not allowed to use user-interface objects.
`
`The following custom OLE 2.0 interfaces are in the core set of XMCSPI func