
The NT3XLI DLL provides a set of functions that simplify access to the Oregon
Micro Systems PC3x family of motor controllers.  DLL functions provide an
interface between the application and the controller's Windows NT device
driver.  The functions generate the approprate controller text command strings
and convert the controller's text responses back into the appropriate binary
form for use by the application.  This is the standard version of the DLL and
uses position and axis parameter values that are in long integer format. 

Requirements:
-  The appropriate Oregon Micro Systems device driver must be installed.
-  The Microsoft runtime DLL, MSVCRT.DLL, must be installed.  A copy is
   located in the BASICDLL subdirectory of this release.

"C" applications:
 -  Use the NT3XLI.H header file to provide constant definitions and function
    prototypes.
 -  Link the application with the import library NT3XLI.LIB.
 -  Place NT3XLI.DLL in the application's directory.

MFC C++ applications:
 -  Use the NT3XLIMF.H header file to provide constant definitions and function
    prototypes.
 -  Link the application with the import library NT3XLI.LIB.
 -  Place NT3XLI.DLL in the application's directory.

Microsoft Visual Basic 4.0 applications:
 -  Use OMS.BAS to provide constant definitions and function declarations.
    Note the Visual Basic function declarations replace the "C" int variables
    with Longs.  This is because the 32 bit version of the "C" and C++ compiler
    define int variables to be 32 bits long while Visual Basic retains a 16 bit
    length for variables of type Integer.
 -  Place the NT3XLI.DLL in the \WINDOWS\SYSTEM directory.
 
   
Function Status Codes:

Most of the functions return one of the following status codes in an int
variable:
  SUCCESS                -  The function executed without an error.
  COMMAND_TIME_OUT       -  The controller did not accept the command with in
                            100 milliseconds.
  INVALID_AXIS_SELECTION -  An invalid axis selection code was passed to the
                            function.
  INVALID_BIT_NUMBER     -  An invalid I/O bit selection number was passed to
                            the function.
  MOVE_TIME_OUT          -  The controller did not complete a move with in the
                            specified time limit.
  RESPONSE_TIME_OUT      -  The controller did not send a text response to a
                            query command with in 100 milliseconds.
  INVALID_PARAMETER      -  An invalid parameter value was supplied to the
                            function.
 

The DLL contains the following functions:                       

1.0 GENERAL BOARD ACCESS FUNCTIONS:
    1.01 GetOmsHandle
    1.02 CloseOmsHandle
    1.03 ResetOmsController
    1.04 SendOmsQueryCommand     
    1.05 SendOmsTextCommand
    
2.0 FUNCTIONS THAT MOVE/STOP A SINGLE AXIS:
    2.01 MoveOmsAxisAbs
    2.02 MoveOmsAxisAbsWait
    2.03 MoveOmsAxisIndefinite
    2.04 MoveOmsAxisFractional
    2.05 MoveOmsAxisRel
    2.06 MoveOmsAxisRelWait
    2.07 MoveOmsAxisOneStep
    2.08 StopOmsAxis
    
3.0 FUNCTIONS THAT MOVE/STOP MULTIPLE AXES IN ALL AXES MODE; 
    3.01 MoveOmsIndependantAbs
    3.02 MoveOmsIndependantAbsWait
    3.03 MoveOmsIndependantRel
    3.04 MoveOmsIndependantRelWait
    3.05 MoveOmsLinearAbs
    3.06 MoveOmsLinearAbsWait
    3.07 MoveOmsLinearRel
    3.08 MoveOmsLinearRelWait
    3.09 KillAllOmsMotion
    3.10 StopAllOmsAxes
    
4.0 FUNCTIONS THAT MOVE MULTIPLE AXES IN MULTITASKING MODE:
    4.01 MoveOmsIndependantAbsMt
    4.02 MoveOmsIndependantAbsMtWait
    4.03 MoveOmsIndependantRelMt    
    4.04 MoveOmsIndependantRelMtWait
    4.05 MoveOmsLinearAbsMt
    4.06 MoveOmsLinearAbsMtWait
    4.07 MoveOmsLinearRelMt
    4.08 MoveOmsLinearRelMtWait
    
5.0 AXIS MOTOR POSITION REPORTING FUNCTIONS
    5.01 GetOmsAxisMotorPosition
    5.02 GetSelectedOmsMotorPositions
    
6.0 AXIS POSITION INITIALIZATION FUNCTIONS:
    6.01 DefineOmsHomeAsSwitchClosed
    6.02 DefineOmsHomeAsSwitchOpen
    6.03 FindOmsAxisFwdLimit
    6.04 FindOmsAxisRevLimit
    6.05 HomeOmsAxisFwdUseEncoder
    6.06 HomeOmsAxisFwdUseEncoderWait
    6.07 HomeOmsAxisFwdUseSwitch
    6.08 HomeOmsAxisFwdUseSwitchWait
    6.09 HomeOmsAxisRevUseEncoder
    6.10 HomeOmsAxisRevUseEncoderWait
    6.11 HomeOmsAxisRevUseSwitch
    6.12 HomeOmsAxisRevUseSwitchWait
    6.13 SetOmsAxisPosition
    
7.0 AXIS VELOCITY CONTROL/REPORTING FUNCTIONS:
    7.01 GetOmsAxisVelocity
    7.02 GetSelectedOmsVelocities
    7.03 SetOmsAxisBaseVelocity
    7.04 SetOmsAxisVelocity
    
8.0 AXIS ACCELERATION CONTROL/REPORTING FUNCTIONS:    
    8.01 GetOmsAxisAcceleration
    8.02 GetSelectedOmsAccelerations
    8.03 SelectOmsCosineRamp
    8.04 SelectOmsLinearRamp
    8.05 SelectOmsParabolicRamp
    8.06 SetOmsAxisAcceleration
    
9.0 CONTROLLER STATUS FUNCTIONS:
    9.01 ClrOmsControllerFlags
    9.02 ClrOmsDoneFlags
    9.03 GetAllOmsDoneFlags      
    9.04 GetOmsAxisDoneFlag
    9.05 GetOmsAxisFlags
    9.06 GetOmsControllerDescription
    9.07 GetOmsControllerFlags
    
10.0 FUNCTIONS SPECIFIC TO ENCODER FEEDBACK SYSTEMS:
    10.01 EnableOmsSlipDetection
    10.02 GetAllOmsSlipFlags
    10.03 GetOmsEncoderFlags
    10.04 GetOmsAxisEncoderPosition
    10.05 SetOmsEncoderHoldMode
    10.06 SetOmsEncoderRatio
    10.07 SetOmsHoldDeadBand
    10.08 SetOmsEncoderSlipTolerance
    10.09 SetOmsHoldGain
    10.10 SetOmsHoldVelocity
    
11.0 FUNCTIONS THAT CONTROL HOW AXIS OVERTRAVEL IS HANDLED:
    11.01 SetOmsAxisOvertravelDetect
    11.02 SetOmsSoftLimitsMode
    
12.0 GENERAL PURPOSE I/O BIT FUNCTIONS:                              
    12.01 GetOmsIOBit
    12.02 GetAllOmsIOBits
    12.03 GetOmsIOBitConfig
    12.04 SetOmsIOBit
    
13.0 AXIS AUXILIARY OUTPUT BIT FUNCTIONS:                              
    13.01 EnableOmsAxisAuxOutAutoMode
    13.02 SetOmsAxisAuxOutBit
    13.03 SetOmsAxisAuxOutSettleTime
    13.04 SetSelectedOmsAuxOutBits

14.0 TIME DELAY FUNCTION:
    14.01 OmsWait
                       
Function Descriptions:

1.0 GENERAL BOARD ACCESS FUNCTIONS:

1.01 HANDLE Oms1Handle = GetOmsHandle(LPSTR szOmsDeviceName)
 
    Get a device handle to an OMS motor controller card.
    The handle will be null if a valid handle could not be acquired.
    This could occur if an invalid device name is provided or the appropriate
    device driver has not been installed.
    
    "C" Example:
    //Define a global device handle variable
    HANDLE Oms1Handle;
    ...
    ...
    Oms1Handle = GetOmsHandle("OMS1"); 
    
    Visual Basic Example:
    'Note OMS.BAS defines this global variable
    Global Oms1Handle As Long
    ...
    ...
    'Place the device handle in a global variable
    Oms1Handle = GetOmsHandle("OMS1")


1.02 void CloseOmsHandle(HANDLE Oms1Handle)
 
    Close the device handle of the specified OMS motor controller card.
    
    "C" Example:
    CloseOmsHandle(Oms1Handle); 

    Visual Basic Example:
    CloseOmsHandle (Oms1Handle)

1.03 int Status = ResetOmsController(HANDLE Oms1Handle)
 
    Send a reset command to the controller. All parameters will be set to
    their default values and the hardware is set to its power up state.
    
    Status return codes: {SUCCESS, COMMAND_TIME_OUT}
    
    "C" Example:
    int Status;
    ...
    ...
    Status = ResetOmsController(Oms1Handle); 
    if(Status == COMMAND_TIME_OUT)
      //The controller did not accept the reset command...
      
    Visual Basic Example:
    Dim Status As Long;
    Status = ResetOmsController(Oms1Handle) 
    If(Status = COMMAND_TIME_OUT) Then
      'The controller did not accept the reset command


1.04  int Status = SendOmsQueryCommand(HANDLE Oms1Handle,     
                                       LPSTR szCommandString,
                                       LPSTR szResponseString)
                                   
    Send a null terminated ASCII command string to the motor controller
    and wait up to 100 milliseconds for the the controller to send a text
    response.  Carriage return and line feed characters will be removed
    and all other characters, preceeding the second line feed, will be returned
    to the application as a null terminated string.  Any characters following
    the second line feed will be discarded.  If the controller does not respond
    to the query command with in 100 milliseconds the response string
    will be set to NULL and an error status of RESPONSE_TIME_OUT will be
    returned.  
    
    Status return codes:{SUCCESS, RESPONSE_TIME_OUT}

    "C" Example:
    int Status;
    char Command[] = "axrp";
    char Response[128];
    ...
    ...
    Status = SendOmsQueryCommand(Oms1Handle, Command, Response);
    if(Status == RESPONSE_TIME_OUT)
       //The controller did not respond with in 100 milliseconds.
       
    Visual Basic Example:
    Dim Status As Long
    'Allocate a variable length string for the command string
    Dim Command As String
    'Allocate a fixed length string to recieve the controller response
    Dim Response As String * 128

    Command = "AARP"
    Status = SendOmsQueryCommand(Oms1Handle, Command, Response)
    If (Status = RESPONSE_TIME_OUT) Then
      'Handle error

    
1.05  int Status = SendOmsTextCommand(HANDLE Oms1Handle, 
                                      LPSTR szCommandString)
 
    Send a null terminated ASCII command string to the motor controller.
    Note any text sent by the controller, in response to the command string,
    will be discarded by the device driver.
    
    Status return codes: {SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    char CommandString[] = "axlp1000;";
    ...
    ...
    Status = SendOmsTextCommand(Oms1Handle, CommandString);
    if(Status == COMMAND_TIME_OUT)
    //Controller did not accept the command string with in 100 milliseconds.
    
    Visual Basic Example:
    Dim Status As Long
    'Allocate a variable length string for the command string
    Dim CommandString As String
    CommandString  = "axlp1000;"
    ...
    ...
    Status = SendOmsTextCommand(Oms1Handle, CommandString)
    If(Status = COMMAND_TIME_OUT) Then
      'Controller did not accept the command string with in 100 milliseconds.


2.0 FUNCTIONS THAT MOVE/STOP A SINGLE AXIS:
       
2.01 int Status = MoveOmsAxisAbs(HANDLE Oms1Handle,
                                 int AxisSelection,
                                 long Position)
                                 
    Move a single axis to the absolute position specified by Position.  The 
    axis done flag will be cleared when the move begins and will be set when
    the move is complete.  This function returns control to the application as
    soon as the command has been accepted by the controller.  It does not wait
    for the move to complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}


    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS;
    Position = 1000;
    Status = MoveOmsAxisAbs(Oms1Handle,
                            AxisSelection,
                            Position);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 1000
    Status = MoveOmsAxisAbs(Oms1Handle, _
                            AxisSelection, _
                            Position)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                              
                              
2.02 int Status = MoveOmsAxisAbsWait(HANDLE Oms1Handle,
                                     int AxisSelection,
                                     long Position,
                                     long MoveTimeLimit) 
                                  
    Move a single axis to the absolute position specified by Position. Control
    will be returned to the application when the axis reaches its target
    position or the number of  milliseconds, specified by the move time limit,
    have elapsed.  The axis done flag will be cleared when the move begins
    and will be set when the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}


    "C" Example:
    int AxisSelection;
    long Position;
    long MoveTimeLimit
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS;
    Position = 1000;
    MoveTimeLimit = 1000;
    Status = MoveOmsAxisAbsWait(Oms1Handle,
                                AxisSelection,
                                Position,
                                MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim MoveTimeLimit As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS
    Position = 1000
    MoveTimeLimit = 1000
    Status = MoveOmsAxisAbsWait(Oms1Handle, _
                                AxisSelection, _
                                Position, _
                                MoveTimeLimit)
    If(Status <> SUCCESS) Then
    'Handle the error conditions
    
 
2.03 int Status = MoveOmsAxisIndefinite(HANDLE Oms1Handle,
                                        int AxisSelection,
                                        long Velocity)
                                        
    Move the selected axis, at the velocity specified by Velocity, until it is
    commanded to stop.  See the StopOmsAxis function described below.
    
    The velocity is limited to the range of -522000 to 522000 steps per second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}


    "C" Example:
    int AxisSelection;
    long Velocity;
    int Status;
    ...
    ...
    //Command the X axis to move at 10000 steps per second until it is stopped.
    AxisSelection = OMS_X_AXIS;
    Velocity = 100000;
    Status = MoveOmsAxisIndefinite(Oms1Handle,
                                   AxisSelection,
                                   Velocity);
    if(Status != SUCCESS)
    //Handle the error conditions
    

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Velocity As Long
    Dim Status As Long
    ...
    ...
    'Command the X axis to move at 10000 steps per second until it is stopped.
    AxisSelection = OMS_X_AXIS
    Velocity = 100000
    Status = MoveOmsAxisIndefinite(Oms1Handle, _
                                   AxisSelection, _
                                   Velocity)
    If(Status <> SUCCESS) Then
    'Handle the error conditions
    
 
2.04  int Status = MoveOmsAxisFractional(HANDLE Oms1Handle,
                                         int AxisSelection,
                                         double dVelocity)
                                                   
    Move the selected axis at the velocity specified by dVelocity until it
    is commanded to stop.  The fractional part of fVelocity will be included
    in the axis velocity.
    
    The velocity is limited to the range of -2000.0 to 2000.0 steps per second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    double Velocity;
    int Status;
    ...
    ...
    //Command the axis to move at 100.25 steps per second until it is stopped.
    AxisSelection = OMS_X_AXIS;
    Velocity = 100.25;
    Status = MoveOmsAxisFractional(Oms1Handle,
                                   AxisSelection,
                                   Velocity);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Velocity As Double
    Dim Status As Long
    ...
    ...
    'Command the axis to move at 100.25 steps per second until it is stopped.
    AxisSelection = OMS_X_AXIS
    Velocity = 100.25
    Status = MoveOmsAxisFractional(Oms1Handle, _
                                   AxisSelection, _
                                   Velocity)
    If(Status <> SUCCESS)Then
      'Handle the error conditions

    
2.05  int Status = MoveOmsAxisRel(HANDLE Oms1Handle,
                                  int AxisSelection,
                                  long Position)
                                  
    Move a single axis to the relative position specified by Position.
    The axis done flag will be cleared when the move begins and will be set
    when the move is complete.  This function will return control to the
    application as soon as the controller has accepted the command.  It will
    not wait until the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 1000;
    Status = MoveOmsAxisRel(Oms1Handle,
                            AxisSelection,
                            Position);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 1000
    Status = MoveOmsAxisRel(Oms1Handle, _
                            AxisSelection, _
                            Position)
    If(Status <> SUCCESS) Then
    'Handle the error conditions

                                   
2.06  int Status = MoveOmsAxisRelWait(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      long Position,
                                      long MoveTimeLimit)  
                                      
    Move a single axis to the relative position specified by Position.
    Control will be returned to the application when the axis reaches its
    target position or the number of milliseconds, specified by the move time
    limit, have elapsed.  The axis done flag will be cleared when the move
    begins and will be set when the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}


    "C" Example:
    int AxisSelection;
    long Position;
    long MoveTimeLimit
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 1000;
    MoveTimeLimit = 1000;
    Status = MoveOmsAxisRelWait(Oms1Handle,
                                AxisSelection,
                                Position,
                                MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim MoveTimeLimit As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 1000
    MoveTimeLimit = 1000
    Status = MoveOmsAxisRelWait(Oms1Handle, _
                                AxisSelection, _
                                Position, _
                                MoveTimeLimit)
    If(Status <> SUCCESS) Then
    'Handle the error conditions


2.07 int Status = MoveOmsAxisOneStep(HANDLE Oms1Handle,
                                     int AxisSelection,
                                     int Direction)
                                     
    Move the selected axis one step in the specified direction.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}
    
    Direction codes = {POSITIVE, NEGATIVE}

    "C" Example:
    int AxisSelection;
    int Direction;
    int Status;
    ...
    ...
    //Command the X axis to move one step in the positive direction.
    AxisSelection = OMS_X_AXIS;
    Direction  = POSITIVE;
    Status = MoveOmsAxisOneStep(Oms1Handle,
                                AxisSelection,
                                Direction);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Direction As Long
    Dim Status As Long
    ...
    ...
    'Command the Y axis to move one step in the positive direction.
    AxisSelection = OMS_Y_AXIS
    Direction  = POSITIVE
    Status = MoveOmsAxisOneStep(Oms1Handle, _
                                AxisSelection, _
                                Direction)
    If(Status <> SUCCESS)Then
    'Handle the error conditions
                              

2.08 int Status = StopOmsAxis(HANDLE Oms1Handle,
                              int AxisSelection)
                              
    Stop the specified axis, using a deceleration ramp, and flush its command
    queue.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT)

    "C" Example:
    int AxisSelection;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS;
    Status = StopOmsAxis(Oms1Handle,
                         AxisSelection);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS
    Status = StopOmsAxis(Oms1Handle, _
                         AxisSelection);
    If(Status <> SUCCESS)...
      'Handle error condition


3.0 FUNCTIONS THAT MOVE/STOP MULTIPLE AXES IN ALL AXES MODE; 
 
 3.01 int Status = MoveOmsIndependantAbs(HANDLE Oms1Handle,
                                         int AxisSelections,
                                         PAXES_DATA Positions)
                                         
    Move the selected set of axes to the absolute positions specified by
    Positions.  All selected axes will start their moves at the same time.
    Each axis will move to its destination independantly, based on its
    own velocity and acceleration limits.  The command is executed in all
    axis mode so that any additional commands, pending in any of the axis
    command queues, will not be executed until the move is complete.  All
    axis done flags will be cleared at the start of the move and set when the
    move is complete.  The function will return control to the application as
    soon as the command has been accepted by the controller.  It does not wait
    until the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    Status = MoveOmsIndependantAbs(Oms1Handle,
                                   AxisSelections,
                                   &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsIndependantAbs(Oms1Handle, _
                                   AxisSelections, _
                                   Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                     
                                     
3.02 int Status = MoveOmsIndependantAbsWait(HANDLE Oms1Handle,
                                            int AxisSelections,
                                            PAXES_DATA Positions,
                                            long MoveTimeLimit)
                                            
    Move the selected set of axes to the absolute positions specified by
    Positions.  All selected axes will begin moving at the same time.
    Each axis will move to its destination independantly based on its own
    velocity and acceleration limits. The command is executed in all axis
    mode so that any additional commands, pending in any of the axis command
    queues, will not be executed until the move is complete.  All axis done
    flags will be cleared at the start of the move and set when the move is
    complete.  Control will be returned to the application when the axes have
    reached their target positions or the number of milliseconds, specified
    by the move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsIndependantAbsWait(Oms1Handle,
                                       AxisSelections,
                                       &Positions,
                                       MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsIndependantAbsWait(Oms1Handle, _
                                       AxisSelections, _
                                       Positions, _
                                       MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions

    
3.03 int Status = MoveOmsIndependantRel(HANDLE Oms1Handle,
                                        int AxisSelections,
                                        PAXES_DATA Positions)
                                        
    Move the selected set of axes to the relative positions specified by
    Positions.  All selected axes will begin moving at the same time.
    Each axis will move to its destination independantly, based on its own
    velocity and acceleration limits.  The command is executed in all axis
    mode so that any additional commands, pending in any of the axis command
    queues, will not be executed until the move is complete.  All axis done
    flags will be cleared when the move begins and set when the move is
    complete.  The function will return control to the application as soon as
    the command has been accepted by the controller.  It does not wait until
    the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    Status = MoveOmsIndependantRel(Oms1Handle,
                                   AxisSelections,
                                   &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsIndependantRel(Oms1Handle, _
                                   AxisSelections, _
                                   Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions

                                     
                                     
3.04 int Status = MoveOmsIndependantRelWait(HANDLE Oms1Handle,
                                            int AxisSelections,
                                            PAXES_DATA Positions,
                                            long MoveTimeLimit)
                                             
    Move the selected set of axes to the relative positions specified by
    Positions.  All selected axes will begin moving at the same time.
    Each axis will move to its destination independantly, based on its own
    velocity and acceleration limits.  The command is executed in all axis
    mode so that any additional commands, pending in any of the axis command
    queues, will not be executed until the move is complete.  All axis done
    flags will be set when the move is complete.  Control will be returned
    to the application when the axes have reached their target positions or
    the number of milliseconds, specified by the move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsIndependantRelWait(Oms1Handle,
                                       AxisSelections,
                                       &Positions,
                                       MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsIndependantRelWait(Oms1Handle, _
                                       AxisSelections, _
                                       Positions, _
                                       MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                       
 
3.05 int Status = MoveOmsLinearAbs(HANDLE Oms1Handle,
                                   int AxisSelections,
                                   PAXES_DATA Positions)
                                   
   Move the selected set of axes to the absolute positions specified by
   Positions.  Use linear interpolation to adjust the velocity and
   acceleration of each axis so that it starts and ends its motion at the
   same time as the other axes.  The command is executed in all axis mode so
   that any commands, pending in any of the axis command queues,  will not be
   executed until the move is complete.  All axis done flags will be cleared
   at the start of the move and set when the move is complete.  The function
   will return control to the application as soon as the command has been
   accepted by the controller.  It does not wait until the move is complete.
   
   Axis position is limited to the range of -67108863 to 67108863 steps.
    
   Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                        INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    Status = MoveOmsLinearAbs(Oms1Handle,
                              AxisSelections,
                              &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsLinearAbs(Oms1Handle, _
                              AxisSelections, _
                              Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                     
                                     
3.06 int Status = MoveOmsLinearAbsWait(HANDLE Oms1Handle,
                                       int AxisSelections,
                                       PAXES_DATA Positions,
                                       long MoveTimeLimit)
                                       
    Move the selected set of axes to the absolute positions specified by
    Positions.  Use linear interpolation to adjust the velocity and
    acceleration of each axis so that it starts and ends its motion at the
    same time as the other axes.  The command is executed in all axis mode
    so that any additional commands, pending in any of the axis command queues,
    will not be executed until the move is complete.  All axis done flags
    will be cleared at the start of the move and set when the move is complete.
    Control will be returned to the application when the axes have reached
    their target positions or the number of milliseconds, specified by the
    move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsLinearAbsWait(Oms1Handle,
                                  AxisSelections,
                                  &Positions,
                                  MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsLinearAbsWait(Oms1Handle, _
                                  AxisSelections, _
                                  Positions, _
                                  MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                             

3.07  int Status = MoveOmsLinearRel(HANDLE Oms1Handle,
                                    int AxisSelections,
                                    PAXES_DATA Positions) 
    
    Move the selected set of axes to the relative positions specified by
    Positions.  Use linear interpolation to adjust the velocity and
    acceleration of each axis so that it starts and ends its motion at the
    same time as the other axes.  The command is executed in all axis mode
    so that any additional commands, pending in any of the axis command queues,
    will not be executed until the move is complete.  All axis done flags will
    be cleared when the move begins and set when the move is complete.  The
    function will return control to the application as soon as the command
    has been accepted by the controller.  It does not wait until the move is
    complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    Status = MoveOmsLinearRel(Oms1Handle,
                              AxisSelections,
                              &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsLinearRel(Oms1Handle, _
                              AxisSelections, _
                              Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                     
                                     
3.08 int Status = MoveOmsLinearRelWait(HANDLE Oms1Handle,
                                       int AxisSelections,
                                       PAXES_DATA Positions,
                                       long MoveTimeLimit)
                                       
    Move the selected set of axes to the relative positions specified by
    Positions.  Use linear interpolation to adjust the 
    velocity and acceleration of each axis so that it starts and ends its
    motion at the same time as the other axes.   The command is executed in all
    axis mode so that any additional commands, pending in any of the axis
    command queues, will not be executed until the move is complete.  All axis
    done flags will be cleared when the move begins and set when the move is
    complete.  Control will be returned to the application when the axes have
    reached their target positions or the number of milliseconds, specified by
    the move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsLinearRelWait(Oms1Handle,
                                  AxisSelections,
                                  &Positions,
                                  MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsLinearRelWait(Oms1Handle, _
                                  AxisSelections, _
                                  Positions, _
                                  MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
    
3.09 int Status = KillAllOmsMotion(HANDLE Oms1Handle)
 
    Stop all axes immediately without using their deceleration ramps, and flush
    their command queues.
 
        
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    ...
    ...
    Status = KillAllOmsMotion(Oms1Handle);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    ...
    ...
    Status = KillAllOmsMotion(Oms1Handle)
    If(Status <> SUCCESS) Then
      'Handle error condition

    
 3.10 int Status = StopAllOmsAxes(HANDLE Oms1Handle)
 
    Stop all axes, using their deceleration ramps, and flush their command
    queues.
        
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    ...
    ...
    Status = StopAllOmsAxes(Oms1Handle);
    if(Status <> SUCCESS) Then
    //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    ...
    ...
    Status = StopAllOmsAxes(Oms1Handle)
    If(Status != SUCCESS)...
      'Handle error condition
    
    
    
4.0 FUNCTIONS THAT MOVE MULTIPLE AXES IN MULTITASKING MODE:

4.01 int Status = MoveOmsIndependantAbsMt(HANDLE Oms1Handle,
                                          int AxisSelections,
                                          PAXES_DATA Positions)
                                          
   Move the selected set of axes to the absolute positions specified by
   Positions.  All selected axes will begin moving at the same time. Each
   axis will move to its destination independantly, based on its own velocity
   and acceleration limits.  The command is executed in multitask mode so that
   any axes, not involved in the move, will continue to execute the commands
   pending in their queues.  The done flags of the selected axes will be
   cleared at the start of the move and set when the move is complete.  This
   function will return control to the application as soon as the command has
   been accepted by the controller.  It does not wait until the move is
   complete.
   
   Axis position is limited to the range of -67108863 to 67108863 steps.
    
   Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                        INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.U = 1000;
    Positions.V = 1500;
    Status = MoveOmsIndependantAbsMt(Oms1Handle,
                                      AxisSelections,
                                      &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsIndependantAbsMt(Oms1Handle, _
                                     AxisSelections, _
                                     Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                       
                                       
4.02 int Status = MoveOmsIndependantAbsMtWait(HANDLE Oms1Handle,
                                              int AxisSelections,
                                              PAXES_DATA Positions,
                                              long MoveTimeLimit)
                                              
    Move the selected set of axes to the absolute positions specified by
    Positions.  All selected axes will begin moving at the same time.
    Each axis will move to its destination independantly, based on its own
    velocity and acceleration limits. The command is executed in  multitask
    mode so that any axes, not involved in the move, will continue to execute
    the commands pending in their queues.  The done flags of the axes involved
    in the move will be cleared when the move begins and set when the move is
    complete.  Control will be returned to the application when the axes have
    reached their target positions or the number of milliseconds, specified
    by the move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsIndependantAbsMtWait(Oms1Handle,
                                         AxisSelections,
                                         &Positions,
                                         MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsIndependantAbsMtWait(Oms1Handle, _
                                         AxisSelections, _
                                         Positions, _
                                         MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                             

4.03 int Status = MoveOmsIndependantRelMt(HANDLE Oms1Handle,
                                          int AxisSelections,
                                          PAXES_DATA Positions)
                                          
    Move the selected set of axes to the relative positions specified by
    Positions.  All selected axes will begin moving at the same time.  Each
    axis will move to its destination independantly, based on its own velocity
    and acceleration limits.  The command is executed in multitask mode so that
    any axes notcinvolved in the move will continue to execute the commands
    pending in their queues.  The done flags of the axes, involved in the move,
    will be cleared when the move begins and set when the move is complete.
    This function will return control to the application as soon as the
    command has been accepted by the controller.  It does not wait until the
    move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.U = 1000;
    Positions.V = 1500;
    Status = MoveOmsIndependantRelMt(Oms1Handle,
                                     AxisSelections,
                                     &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsIndependantRelMt(Oms1Handle, _
                                     AxisSelections, _
                                     Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                       
                                       
4.04 int Status = MoveOmsIndependantRelMtWait(HANDLE Oms1Handle,
                                              int AxisSelections,
                                              PAXES_DATA Positions,
                                              long MoveTimeLimit)
                                              
    Move the selected set of axes to the relative positions specified by
    Positions.  All selected axes will begin moving at the same time.  Each
    axis will move to its destination independantly, based on its own velocity
    and acceleration limits.  The command is executed in multitask mode so that
    any axes not involved in the move will continue to execute the commands
    pending in their queues.  The done flags of the selected axes will be
    cleared at the start of the move and will be set when the move is complete.
    Control will be returned to the application when the axes have reached
    their target positions or the number of milliseconds, specified by the
    move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsIndependantRelMtWait(Oms1Handle,
                                         AxisSelections,
                                         &Positions,
                                         MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsIndependantRelMtWait(Oms1Handle, _
                                         AxisSelections, _
                                         Positions, _
                                         MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    

4.05 int Status = MoveOmsLinearAbsMt(HANDLE Oms1Handle,
                                     int AxisSelections,
                                     PAXES_DATA Positions)
                                     
    Move the selected set of axes to the absolute positions specified by
    Positions.  Use linear interpolation to adjust the velocity and
    acceleration of each axis so that it starts and ends its motion at the
    same time as the other axes.  The command is executed in multitask mode
    so that any axes not involved in the move will continue to execute the
    commands pending in their queues.  The done flags of the axes,  involved
    in the move, will be cleared when the move begins and set when the move
    is complete.  The function will return control to the application as soon
    as the command has been accepted by the controller.  It will not wait until
    the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.U = 1000;
    Positions.V = 1500;
    Status = MoveOmsLinearAbsMt(Oms1Handle,
                                AxisSelections,
                                &Positions);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsLinearAbsMt(Oms1Handle, _
                                AxisSelections, _
                                Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                       
                                       
4.06 int Status = MoveOmsLinearAbsMtWait(HANDLE Oms1Handle,
                                         int AxisSelections,
                                         PAXES_DATA Positions,
                                         long MoveTimeLimit)
                                         
    Move the selected set of axes to the absolute positions specified by
    Positions.  Use linear interpolation to adjust the velocity and
    acceleration of each axis so that it starts and ends its motion at the
    same time as the other axes.  The command is executed in  multitask mode
    so that any axes not involved in the move will continue to execute the
    commands pending in their queues.  The done flags of the axes, involved
    in the move, will be cleared when the move begins and set when the move
    is complete.  Control will be returned to the application when the axes
    have reached their target positions or the number of milliseconds, 
    specified by the move time limit, have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsLinearAbsMtWait(Oms1Handle,
                                     AxisSelections,
                                     &Positions,
                                     MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsLinearAbsMtWait(Oms1Handle, _
                                    AxisSelections, _
                                    Positions, _
                                    MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
    
4.07 int Status = MoveOmsLinearRelMt(HANDLE Oms1Handle,
                                     int AxisSelections,
                                     PAXES_DATA Positions)
                                     
    Move the selected set of axes to the relative positions specified by
    Positions.  Use linear interpolation to adjust the velocity and
    acceleration of each axis so that it starts and ends its motion at the
    same time as the other axes.  The command is executed in multitask mode
    so that any axes, not involved in the move, will continue to execute the
    commands pending in their queues.  The done flags of the axes involved
    in the move will be cleared when the move begins and set when the move
    is complete.  The function will return control to the application as soon
    as the command has been accepted by the controller.  It does not wait until
    the move is complete.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelections;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.U = 1000;
    Positions.V = 1500;
    Status = MoveOmsLinearRelMt(Oms1Handle,
                                AxisSelections,
                                &Positions);
    if(Status != SUCCESS)
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    Status = MoveOmsLinearRelMt(Oms1Handle, _
                                AxisSelections, _
                                Positions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
                                       
                                       
4.08  int Status = MoveOmsLinearRelMtWait(HANDLE Oms1Handle,
                                          int AxisSelections,
                                          PAXES_DATA Positions,
                                          long MoveTimeLimit)
                                         
    Move the selected set of axes to the relative  positions specified by
    Positions.  Use linear interpolation to adjust the velocity and
    acceleration of each axis so that it starts and ends its motion at the
    same time as the other axes.  The command is executed in multitask mode
    so that any axes not involved in the move will continue to execute the
    commands pending in their queues.  The done flags of the axes involved
    in the move will be cleared when the move begins and set when the move
    is complete.  Control will be returned to the application when the axes
    have reached their target positions or the number of milliseconds
    specified by the move time limit have elapsed.
    
    Axis position is limited to the range of -67108863 to 67108863 steps.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}
    
    "C" Example:
    int AxisSelections;
    long MoveTimeLimit;
    AXES_DATA Positions;
    int Status;
    ...
    ...
    AxisSelections = OMS_X_AXIS | OMS_Y_AXIS;
    Positions.X = 1000;
    Positions.Y = 1500;
    MoveTimeLimit = 1000;
    Status = MoveOmsLinearRelMtWait(Oms1Handle,
                                    AxisSelections,
                                    &Positions,
                                    MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle the error conditions
    
    Visual Basic Example:
    Dim AxisSelections As Long
    Dim MoveTimeLimit As Long
    Dim Positions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelections = OMS_X_AXIS + OMS_Y_AXIS
    Positions.X = 1000
    Positions.Y = 1500
    MoveTimeLimit = 1000
    Status = MoveOmsLinearRelMtWait(Oms1Handle, _
                                    AxisSelections, _
                                    Positions, _
                                    MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions


5.0 AXIS MOTOR POSITION REPORTING FUNCTIONS
       
5.01 int Status = GetOmsAxisMotorPosition(HANDLE Oms1Handle,  
                                          int AxisSelection,
                                          long *PositionPointer)
                                           
    Return the motor position of the selected axis.  The position is returned
    in the long integer variable pointed to by PositionPointer.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    long MotorPosition;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS;
    Status = GetOmsAxisMotorPosition(Oms1Handle,
                                     AxisSelection,
                                     &MotorPosition);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim MotorPosition As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS
    Status = GetOmsAxisMotorPosition(Oms1Handle, _
                                     AxisSelection, _
                                     MotorPosition)
    If(Status <> SUCCESS) Then
      'Handle the error conditions

    
5.02 int Status = GetSelectedOmsMotorPositions(HANDLE   Oms1Handle,
                                               int AxisSelection,
                                               PAXES_DATA MotorPositions)
                                                
    Return the current motor positions of the selected axes.  The position data
    is returned via the structure MotorPositions in long integer format.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    AXES_DATA MotorPositions;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS | OMS_Y_AXIS;
    Status = GetSelectedOmsMotorPositions(Oms1Handle,
                                          AxisSelection,
                                          &MotorPositions);
    if(Status != SUCCESS)
    //Handle the error conditions
    else
    {
      printf("X axis position = %d\n", MotorPositions.X);
      printf("Y axis position = %d\n", MotorPositions.Y);
    }  

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim MotorPositions As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS + OMS_Y_AXIS
    Status = GetSelectedOmsMotorPositions(Oms1Handle, _
                                          AxisSelection, _
                                          MotorPositions)
    If(Status <> SUCCESS) Then
      'Handle the error conditions


6.0 AXIS POSITION INITIALIZATION FUNCTIONS:
        
6.01 int Status = DefineOmsHomeAsSwitchClosed(HANDLE Oms1Handle,
                                              int AxisSelection)
                                             
    Define the home position of the selected axis as the point at which the
    axis home switch closes.  This is the default state following a power up
    or reset.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS;
    Status = DefineOmsHomeAsSwitchClosed(Oms1Handle,
                                         AxisSelection);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS
    Status = DefineOmsHomeAsSwitchClosed(Oms1Handle, _
                                         AxisSelection)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
 
        
6.02 int Status = DefineOmsHomeAsSwitchOpen(HANDLE Oms1Handle,
                                            int AxisSelection)
                                           
    Define the home position of the selected axis as the point at which the
    axis home switch opens.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS;
    Status = DefineOmsHomeAsSwitchOpen(Oms1Handle,
                                     AxisSelection);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS
    Status = DefineOmsHomeAsSwitchOpen(Oms1Handle, _
                                       AxisSelection)
    If(Status <> SUCCESS) Then
      'Handle the error conditions

        
6.03 int Status = FindOmsAxisFwdLimit(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      long Velocity,
                                      long MoveTimeLimit)
                                      
    Move the selected axis in the forward direction, at the specified velocity,
    until it arrives at its forward overtravel limit.  The function will return
    control to the application when the overtravel limit is detected or the
    number of milliseconds, specified by the move time limit, have elapsed.
    The velocity is limited to the range of 1 to 522000 steps per second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long MoveTimeLimit;
    long Velocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    //Move axis at 10000 steps per second.
    Velocity = 10000; 
    //Wait up to ten seconds for the axis to find the overtravel limit
    MoveTimeLimit = 10000;
    Status = FindOmsAxisFwdLimit(Oms1Handle,
                                 AxisSelection,
                                 Velocity,
                                 MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim MoveTimeLimit As Long
    Dim Velocity As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    'Move axis at 10000 steps per second.
    Velocity = 10000 
    'Wait up to ten seconds for the axis to find the overtravel limit
    MoveTimeLimit = 10000
    Status = FindOmsAxisFwdLimit(Oms1Handle, _
                                 AxisSelection, _
                                 Velocity, _
                                 MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle error condition

        
6.04 int Status = FindOmsAxisRevLimit(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      long Velocity
                                      long MoveTimeLimit)

    Move the selected axis in the reverse direction, at the specified velocity,
    until it arrives at its overtravel limit. The function will return control
    to the application when the overtravel limit is detected or the number of
    milliseconds, specified by the move time limit, have elapsed.
    The velocity is limited to the range of 1 to 522000 steps per second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long MoveTimeLimit;
    long Velocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    //Move the axis at 10000 steps per second
    Velocity = 10000;
    //Wait up to ten seconds for the axis to find the overtravel limit
    MoveTimeLimit = 10000;
    Status = FindOmsAxisRevLimit(Oms1Handle,
                                 AxisSelection,
                                 Velocity,
                                 MoveTimeLimit);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim MoveTimeLimit As Long
    Dim Velocity As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    'Move axis at 10000 steps per second.
    Velocity = 10000 
    'Wait up to ten seconds for the axis to find the overtravel limit
    MoveTimeLimit = 10000
    Status = FindOmsAxisRevLimit(Oms1Handle, _
                                 AxisSelection, _
                                 Velocity, _
                                 MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle error condition
        
6.05 int Status = HomeOmsAxisFwdUseEncoder(HANDLE Oms1Handle,
                                           int AxisSelection,
                                           long Position)
                                           
    Move the selected axis in the forward direction until it activates the
    home limit switch and the encoder index position is detected.  When the
    home position is detected set the axis position to Position and stop the
    axis.  The axis done flag will be cleared when the
    home operation begins and will be set when it is complete.
    This function returns control to the application as soon as the command has
    been accepted by the controller.  It does not wait for the home operation
    to complete.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    Status = HomeOmsAxisFwdUseEncoder(Oms1Handle,
                                      AxisSelection,
                                      Position);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    Status = HomeOmsAxisFwdUseEncoder(Oms1Handle, _
                                      AxisSelection, _
                                      Position)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
 
        
6.06 int Status = HomeOmsAxisFwdUseEncoderWait(HANDLE Oms1Handle,
                                                int AxisSelection,
                                                long Position,
                                                long MoveTimeLimit)
                                                
    Move the selected axis in the forward direction until it activates the home
    limit switch and the encoder index position is detected. When home position
    is detected set the axis position to Position and
    stop the axis.  The axis done flag will be cleared when the home operation
    begins and will be set when its is complete.  Control will be returned to
    the application when the home operation is complete or the number of
    milliseconds, specified by the move time limit, have elapsed.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                        MOVE_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    //Wait up to 10 seconds for the home operation to complete.
    MoveTimeLimit = 10000;
    Status = HomeOmsAxisFwdUseEncoderWait(Oms1Handle,
                                          AxisSelection,
                                          Position,
                                          MoveTimeLimit);
    if(Status == MOVE_TIME_OUT)...
    //Handle the home time out condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    Dim MoveTimeLimit As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    MoveTimeLimit = 10000
    Status = HomeOmsAxisFwdUseEncoderWait(Oms1Handle, _
                                          AxisSelection, _
                                          Position, _
                                          MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
 
        
6.07 int Status = HomeOmsAxisFwdUseSwitch(HANDLE Oms1Handle,
                                          int AxisSelection,
                                          long Position)
                                           
    Move the selected axis in the forward direction until it activates the
    home limit switch.  When the axis is at home set the axis position to
    Position and stop the axis.  The axis done flag will be
    cleared when the home operation begins and will be set when it is complete.
    This function returns control to the application as soon as the command has
    been accepted by the controller.  It does not wait for the home operation
    to complete.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Reverse the sense of the home switch.  See the DefineOmsHomeAsSwitchOpen
       and DefineOmsHomeAsSwitchClosed functions.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    Status = HomeOmsAxisFwdUseSwitch(Oms1Handle,
                                     AxisSelection,
                                     Position);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    Status = HomeOmsAxisFwdUseSwitch(Oms1Handle, _
                                     AxisSelection, _
                                     Position)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
 
        
6.08  int Status = HomeOmsAxisFwdUseSwitchWait(HANDLE Oms1Handle,
                                               int AxisSelection,
                                               long Position,
                                               long MoveTimeLimit)
                                               
    Move the selected axis in the forward direction until it activates the home
    limit switch. When the axis is at home set the axis position to the integer
    part of Position and stop the axis.  The axis done flag will be cleared
    when the operation begins and will be set when it is complete.  Control
    will be returned to the application when the home operation is complete or
    the number of milliseconds, specified by the move time limit, have elapsed.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Reverse the sense of the home switch.  See the DefineOmsHomeAsSwitchOpen
       and DefineOmsHomeAsSwitchClosed functions.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    long MoveTimeLimit;
    int Status;
    ...
    ...
    
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    //Wait up to 10 seconds for the X axis to find home.
    MoveTimeLimit = 10000;
    Status = HomeOmsAxisFwdUseSwitchWait(Oms1Handle,
                                         AxisSelection,
                                         Position,
                                         MoveTimeLimit);
    if(Status == MOVE_TIME_OUT)...
    //Handle the home time out

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    Dim MoveTimeLimit As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    MoveTimeLimit = 10000
    Status = HomeOmsAxisFwdUseSwitchWait(Oms1Handle, _
                                         AxisSelection, _
                                         Position, _
                                         MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
 
        
6.09 int Status = HomeOmsAxisRevUseEncoder(HANDLE Oms1Handle,
                                           int AxisSelection,
                                           long Position)
                                           
    Move the selected axis in the reverse direction until it activates the
    home limit switch and the encoder index position is detected.  When home
    is detected set the axis position to Position and
    stop the axis.  The axis done flag will be cleared when the home operation
    begins and will be set when it is complete.  This function returns control
    to the application as soon as the command has been accepted by the
    controller.  It does not wait for the home operation to complete.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    Status = HomeOmsAxisRevUseEncoder(Oms1Handle,
                                      AxisSelection,
                                      Position);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    Status = HomeOmsAxisRevUseEncoder(Oms1Handle, _
                                      AxisSelection, _
                                      Position)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
 
        
6.10 int Status = HomeOmsAxisRevUseEncoderWait(HANDLE Oms1Handle,
                                               int AxisSelection,
                                               long Position,
                                               long MoveTimeLimit)
                                               
    Move the selected axis in the reverse direction it activates the home limit
    switch and the encoder index position is detected.  When home is detected
    set the axis position to Position and stop the axis.
    The axis done flag will be cleared when the home operation begins and will
    be set when its is complete.  Control will be returned to the application
    when the home operation is complete or the number of milliseconds, specified
    by the move time limit, have elapsed.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    //Wait up to 10 seconds for the home operation to complete.
    MoveTimeLimit = 10000;
    Status = HomeOmsAxisRevUseEncoderWait(Oms1Handle,
                                          AxisSelection,
                                          Position,
                                          MoveTimeLimit);
    if(Status == MOVE_TIME_OUT)...
    //Handle the home time out condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    Dim MoveTimeLimit As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    MoveTimeLimit = 10000
    Status = HomeOmsAxisRevUseEncoderWait(Oms1Handle, _
                                          AxisSelection, _
                                          Position, _
                                          MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
                              
        
6.11 int Status = HomeOmsAxisRevUseSwitch(HANDLE Oms1Handle,
                                           int AxisSelection,
                                           long Position)
                                           
    Move the selected axis in the reverse direction until it activates the
    home limit switch. When the home position is detected set the axis position
    Position and stop the axis. The axis done flag will
    be cleared when the home operation begins and will be set when it is
    complete. This function returns control to the application as soon as the
    command has been accepted by the controller.  It does not wait for the home
    operation to complete.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Reverse the sense of the home switch.  See the DefineOmsHomeAsSwitchOpen
       and DefineOmsHomeAsSwitchClosed functions.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    Status = HomeOmsAxisRevUseSwitch(Oms1Handle,
                                     AxisSelection,
                                     Position);
    if(Status != SUCCESS)
    //Handle the error conditions
    

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    Status = HomeOmsAxisRevUseSwitch(Oms1Handle, _
                                     AxisSelection, _
                                     Position)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
 
        
6.12 int Status = HomeOmsAxisRevUseSwitchWait(HANDLE Oms1Handle,
                                              int AxisSelection,
                                              long Position,
                                              long MoveTimeLimit)
                                               
    Move the selected axis in the reverse direction until it activates the
    home limit switch.  When home is detected set the axis position to
    Position and stop the axis.  The axis done flag will be
    cleared when the operation begins and will be set when it is complete.
    Control will be returned to the application when the home operation is
    complete or the number of milliseconds, specified by the move time limit,
    have elapsed.
    Note to minimize position error the velocity of the axis should be less
    than 1024 steps per second when the home switch is activated.  If the
    axis is a large distance from home it is faster to:
    -  Set tha axis velocity to a higher value than 1024.
    -  Home the axis.
    -  Reverse the sense of the home switch.  See the DefineOmsHomeAsSwitchOpen
       and DefineOmsHomeAsSwitchClosed functions.
    -  Set the axis velocity to less than 1024.
    -  Home the axis in the opposite direction.   
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         MOVE_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Position;
    long MoveTimeLimit;
    int Status;
    ...
    ...
    
    AxisSelection = OMS_Y_AXIS;
    Position = 100;
    //Wait up to 10 seconds for the X axis to find home.
    MoveTimeLimit = 10000;
    Status = HomeOmsAxisRevUseSwitchWait(Oms1Handle,
                                         AxisSelection,
                                         Position,
                                         MoveTimeLimit);
    if(Status == MOVE_TIME_OUT)...
    //Handle the home time out

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    Dim MoveTimeLimit As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 100
    MoveTimeLimit = 10000
    Status = HomeOmsAxisRevUseSwitchWait(Oms1Handle, _
                                         AxisSelection, _
                                         Position, _
                                         MoveTimeLimit)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
    
    
6.13 int Status = SetOmsAxisPosition(HANDLE Oms1Handle,
                                     int AxisSelection,
                                     long Position)
                                     
    Set the position of the selected axis to the value contained in Position.
    Axis position is limited to the range of -67108863 to 67108863. 
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT
                         INVALID_PARAMETER)

    "C" Example:
    int AxisSelection;
    long Position;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Position = 1000;
    Status = SetOmsAxisPosition(Oms1Handle,
                                AxisSelection,
                                Position);
    if(Status != SUCCESS)
    //Handle error condition
    
    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Position As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Position = 1000
    Status = SetOmsAxisPosition(Oms1Handle, _
                                AxisSelection, _
                                Position)
    If(Status <> SUCCESS)Then
      'Handle error condition


       
7.0 AXIS VELOCITY CONTROL/REPORTING FUNCTIONS:
       
7.01 int Status = GetOmsAxisVelocity(HANDLE Oms1Handle,
                                     int AxisSelection,
                                     long *DataPointer)
                                     
    Return the current velocity of the selected axis.  The velocity is placed
    in the long integer variable pointed to by DataPointer.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    long Velocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = GetOmsAxisVelocity(Oms1Handle,
                                AxisSelection,
                                &Velocity);
    if(Status != SUCCESS)
    //Handle the error conditions
      
    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Velocity As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = GetOmsAxisVelocity(Oms1Handle, _
                                AxisSelection, _
                                Velocity)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
      

    
7.02 int Status = GetSelectedOmsVelocities(HANDLE Oms1Handle,
                                           int AxisSelection,
                                           PAXES_DATA Velocity)
                                            
    Return the current velocities of the selected axes.  The velocities are
    placed in the structure Velocity as long integer variables. 
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    AXES_DATA Velocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS | OMS_Y_AXIS;
    Status = GetSelectedOmsVelocities(Oms1Handle,
                                      AxisSelection,
                                      &Velocity);
    if(Status != SUCCESS)
    //Handle the error conditions
    else
    {
      printf("X axis current velocity = %d\n", Velocity.X);
      printf("Y axis current velocity = %d\n", Velocity.Y);
    }  

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Velocity As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS + OMS_Y_AXIS
    Status = GetSelectedOmsVelocities(Oms1Handle, _
                                      AxisSelection, _
                                      Velocity)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    

        
7.03 int Status = SetOmsAxisBaseVelocity(HANDLE Oms1Handle,
                                         int AxisSelection,
                                         long Velocity)
                                         
    Set the minimum velocity of the selected axis to the value contained in
    Velocity.  Setting a nonzero base velocity allows a motor to accelerate
    through resonance as fast as possible. Velocity is limited to the range of
    0 to 522000 steps per second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Velocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    //Minimum velocity of the X axis velocity is 100 steps per second.
    Velocity = 100;
    Status = SetOmsAxisBaseVelocity(Oms1Handle,
                                    AxisSelection,
                                    Velocity);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Velocity As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    'Minimum velocity of the Y axis velocity is 100 steps per second.
    Velocity = 100
    Status = SetOmsAxisBaseVelocity(Oms1Handle, _
                                    AxisSelection, _
                                    Velocity)
    If(Status <> SUCCESS) Then
      'Handle error condition

        
7.04  int Status = SetOmsAxisVelocity(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      long Velocity)
                                     
    Set the maximum velocity of the selected axis to the value contained in
    Velocity.  The velocity is limited to the range of  1 to 522000 steps per
    second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT.
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Velocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    //Limit X axis velocity to 1000 steps per second.
    Velocity = 1000;
    Status = SetOmsAxisVelocity(Oms1Handle,
                                AxisSelection,
                                Velocity);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Velocity As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    'Limit X axis velocity to 1000 steps per second.
    Velocity = 1000
    Status = SetOmsAxisVelocity(Oms1Handle, _
                                AxisSelection, _
                                Velocity)
    If(Status <> SUCCESS) Then
      'Handle error condition

    

8.0 AXIS ACCELERATION CONTROL/REPORTING FUNCTIONS:    
       
8.01 int Status = GetOmsAxisAcceleration(HANDLE Oms1Handle,
                                         int AxisSelection,
                                         long *DataPointer)
                                         
    Return the maximum acceleration limit for the selected axis.  The
    acceleration limit will be placed in the long integer variable pointed
    to by DataPointer.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    long MaxAccel;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = GetOmsAxisAcceleration(Oms1Handle,
                                    AxisSelection,
                                    &MaxAccel);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim MaxAccel As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = GetOmsAxisAcceleration(Oms1Handle, _
                                    AxisSelection, _
                                    MaxAccel)
    If(Status <> SUCCESS) Then
      'Handle the error conditions

    
8.02 int Status = GetSelectedOmsAccelerations(HANDLE Oms1Handle,
                                              int AxisSelection,
                                              PAXES_DATA AccelLimits)
                                              
    Return the maximum acceleration limits for the selected axes.  The
    acceleration limits are placed in the structure AccelLimits as long
    precision variables.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    AXES_DATA AccelLimits;
    int Status;
    ...
    ...
    AxisSelection = OMS_X_AXIS | OMS_Y_AXIS;
    Status = GetSelectedOmsAccelerations(Oms1Handle,
                                         AxisSelection,
                                         &AccelLimits);
    if(Status != SUCCESS)
    //Handle the error conditions


    Visual Basic Example:
    Dim AxisSelection As Long
    Dim AccelLimits As AXES_DATA
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_X_AXIS + OMS_Y_AXIS
    Status = GetSelectedOmsAccelerations(Oms1Handle, _
                                         AxisSelection, _
                                         AccelLimits)
    If(Status <> SUCCESS) Then
      'Handle the error conditions

        
8.03 int Status = SelectOmsCosineRamp(HANDLE Oms1Handle)
    Select the use of a cosine acceleration ramp for all axes.
    
    The following table describes the cosine acceleration ramp:
    
    Acceleration        Until axis 
    applied to motor    velocity reaches
    15.6% of maximum      2.4%  of maximum           
    45.4% of maximum      9.5%  of maximum
    70.7% of maximum     20.6%  of maximum
    79.1% of maximum     34.5%  of maximum
    89.1% of maximum     50.0%  of maximum
    98.7% of maximum     65.5%  of maximum
    89.1% of maximum     79.4%  of maximum
    70.7% of maximum     90.4%  of maximum
    45.4% of maximum     97.6%  of maximum
    15.6% of maximum     100.0% of maximum
    
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    ...
    ...
    Status = SelectOmsCosineRamp(Oms1Handle);
    if(Status != SUCCESS)
      //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    ...
    ...
    Status = SelectOmsCosineRamp(Oms1Handle)
    If(Status <> SUCCESS) Then
      'Handle error condition

        
8.04 int Status =  SelectOmsLinearRamp(HANDLE Oms1Handle)
    Select the use of a linear acceleration ramp for all axes.
    
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    ...
    ...
    Status = SelectOmsLinearRamp(Oms1Handle);
    if(Status != SUCCESS)
      //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    ...
    ...
    Status = SelectOmsLinearRamp(Oms1Handle)
    If(Status <> SUCCESS) Then
      'Handle error condition
      

        
8.05  int Status = SelectOmsParabolicRamp(HANDLE Oms1Handle,
                                          int RampSteps)
                                          
    Select the use of a parabolic acceleration ramp and the number of
    steps in the ramp.  This selection is effective for all axes.
    
    Status return codes:{SUCCESS, COMMAND_TIME_OUT, INVALID_PARAMETER}
    
    If RampSteps is set equal to zero then the following table describes the
    axis acceleration velocity relationship:
    
    Acceleration        Velocity
                        Break Point
    100% of max         33% of max           
     90% of max         67% of max
     80% of max         100% of max 
                        
    If RampSteps is between 3 and 10 then the number of steps determine at what
    point the acceleration ramp will be truncated.  The following table
    describes the acceleration ramp:
    
    Ramp Steps  Acceleration        Until axis 
                applied to motor    velocity reaches
                100% of maximum     19% of maximum           
                 90% of maximum     36% of maximum
        3        80% of maximum     51% of maximum
        4        70% of maximum     64% of maximum
        5        60% of maximum     75% of maximum
        6        50% of maximum     84% of maximum
        7        40% of maximum     91% of maximum
        8        30% of maximum     96% of maximum
        9        20% of maximum     99% of maximum
        10       10% of maximum    100% of maximum

    "C" Example:
    int RampSteps;
    int Status;
    ...
    ...
    
    RampSteps = 10:
    Status = SelectOmsParabolicRamp(Oms1Handle,
                                    RampSteps);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    Dim RampSteps As Long
    ...
    ...
    RampSteps = 10
    Status = SelectOmsParabolicRamp(Oms1Handle, _
                                    RampSteps)
    If(Status <> SUCCESS) Then
      'Handle error condition

        
8.06 int Status = SetOmsAxisAcceleration(HANDLE Oms1Handle,
                                         int AxisSelection,
                                         long Acceleration)
                                         
    Set the maximum acceleration of the selected axis to the value contained
    in Acceleration.  Acceleration is limited to the range of 1 to 2000000
    steps per second per second.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long Acceleration;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    //Limit axis acceleration to 10000 steps//sec/sec
    Acceleration = 10000;
    Status = SetOmsAxisAcceleration(Oms1Handle,
                                    AxisSelection,
                                    Acceleration);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Acceleration As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    'Limit axis acceleration to 10000 steps//sec/sec
    Acceleration = 10000
    Status = SetOmsAxisAcceleration(Oms1Handle, _
                                    AxisSelection, _
                                    Acceleration)
    If(Status <> SUCCESS) Then
      'Handle error condition
       
    

9.0 CONTROLLER STATUS FUNCTIONS:
       
9.01 int Status =  ClrOmsControllerFlags(HANDLE Oms1Handle,  
                                         int FlagMask)
                                
    Clear the latched status flag bits selected by FlagMask.
    The contoller status flags include:
    Bit 0 = COMMAND_ERROR
    Bit 1 = -
    Bit 2 = ENCODER_SLIP
    Bit 3 = OVERTRAVEL_ERROR
    
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}
    

    "C" Example:
    int FlagMask;
    int Status;
    ...
    ...
    //Clear the command error status flag
    FlagMask = COMMAND_ERROR;
    Status = ClrOmsControllerFlags(Oms1Handle,
                                   FlagMask);
                                   
    if(Status != SUCCESS)
    //Handle error condition                               

    Visual Basic Example:
    Dim FlagMask As Long
    Dim Status As Long
    ...
    ...
    'Clear the command error status flag
    FlagMask = COMMAND_ERROR
    Status = ClrOmsControllerFlags(Oms1Handle, _
                                   FlagMask)
                                   
    If(Status <> SUCCESS) Then
      'Handle error condition                               
                         
       
9.02 int Status = ClrOmsDoneFlags(HANDLE Oms1Handle,  
                                  int AxisSelection)
                                  
    Clear the done flags of the selected axes.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION}

    "C" Example:
    int AxisSelection;
    int Status;
    ...
    ...
    //Clear the X & Y axis done flags
    AxisSelection = (OMS_X_AXIS | OMS_Y_AXIS);
    Status = ClrOmsDoneFlags(Oms1Handle,
                             AxisSelection);
    if(Status != SUCCESS)
    //Handle the error conditions

    Visual Basci Example:
    Dim AxisSelection As Long
    Dim Status As Long
    ...
    ...
    'Clear the X & Y axis done flags
    AxisSelection = OMS_X_AXIS + OMS_Y_AXIS
    Status = ClrOmsDoneFlags(Oms1Handle, _
                             AxisSelection)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    
       
9.03 int Status = DoneFlags GetAllOmsDoneFlags(HANDLE Oms1Handle, int *DoneFlags)
                            
    Returns the done flag status as an unsigned int.
    
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int DoneFlags;
    int Status;
    ...
    ...
     Status = GetAllOmsDoneFlags(Oms1Handle, &DoneFlags);
     if(Status == SUCCESS)
        if((DoneFlags & (OMS_X_AXIS | OMS_Y_AXIS)) == (OMS_X_AXIS | OMS_Y_AXIS))
       //Handle X & Y axis done condition...

    Visual Basic Example:
    Dim DoneFlags As Long
    Dim Status As Long
    ...
    ...
     Status = GetAllOmsDoneFlags(Oms1Handle, DoneFlags)
     If(Status = SUCCESS) Then
        If((DoneFlags And (OMS_X_AXIS + OMS_Y_AXIS)) _
            = (OMS_X_AXIS + OMS_Y_AXIS)) Then
       'Handle X & Y axis done condition...
    
       
9.04 int Status = GetOmsAxisDoneFlag(HANDLE Oms1Handle,  
                                     int AxisSelection,
                                     BOOL *DataPointer)
                                    
    Return the done flag status of the selected axis, in the boolean variable
    pointed to by DataPointer.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION}

    "C" Example:
    int AxisSelection;
    BOOL X_Done;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = GetOmsAxisDoneFlag(Oms1Handle,
                                AxisSelection,
                                &X_Done);
    if(Status != SUCCESS)
    //Handle the error conditions
    else
      If(X_Done)
      //Handle axis done condition...

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Y_Done As Boolean
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = GetOmsAxisDoneFlag(Oms1Handle, _
                                AxisSelection, _
                                Y_Done)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    else
      If(Y_Done) Then
        'Handle axis done condition...

       
9.05 int Status = GetOmsAxisFlags(HANDLE Oms1Handle,  
                                  int AxisSelection,
                                  int *DataPointer)
                                 
    Return the state of the status flags for the selected axis.  The status
    data is returned in the int variable pointed to by DataPointer.
    Status byte format is as follows:
    Bit 0 = DIRECTION   = {POSITIVE = 0, NEGATIVE = 1}
    Bit 1 = DONE        = {FALSE = 0, TRUE = 1}
    Bit 2 = OVERTRAVEL  = {FALSE = 0, TRUE = 1}
    Bit 3 = HOME_SWITCH = {FALSE = 0, TRUE = 1}
    The axis done flag status is acquired from the done flags that are latched
    by the device driver.  The direction, overtravel and  status is
    acquired via the QA command.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, RESPONSE_TIME_OUT}

    "C" Example:
    int AxisSelection;
    int AxisFlags;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = GetOmsAxisFlags(Oms1Handle,
                             AxisSelection,
                             &AxisFlags);
    if(Status != SUCCESS)
      //Handle the error conditions
    else
      //Process the flag bits
      if((AxisFlags & OVERTRAVEL) != 0)
        //Handle axis overtravel

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim AxisFlags As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = GetOmsAxisFlags(Oms1Handle, _
                             AxisSelection, _
                             AxisFlags)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    Else  
      'Process the flag bits
      If((AxisFlags And OVERTRAVEL) <> 0) Then
        'Handle Axis Overtravel
       
       
9.06 int Status = GetOmsControllerDescription(HANDLE Oms1Handle,  
                                              LPSTR  Description)
                                             
    Return the controller's ASCII description in the string pointed to by
    by Description.  The description string contains the controller model,
    firmware version and the number and configuration of its axes.  For example
    "PC38 ver 2.16-4e" would be the description of a PC38 having four stepper
    axes.  All four axes have encoder feed back capabilities.
        
    Status return codes:{SUCCESS, RESPONSE_TIME_OUT}

    "C" Example:
    char   Description[128];
    int Status;
    ...
    ...
    Status = GetOmsControllerDescription(Oms1Handle,
                                         Description);
    if(Status != SUCCESS)
    //Handle the error conditions
    else
      ...

    Visual Basic Example:
    'Allocate a fixed length string for the description
    Dim Description As String*128
    Dim Status As Long
    ...
    ...
    Status = GetOmsControllerDescription(Oms1Handle, _
                                         Description)
    If(Status <> SUCCESS) Then
      'Handle the error condition
    Else
      'Process the description string
    
       
9.07  int Status = GetOmsControllerFlags(HANDLE Oms1Handle,  
                                         int *DataPointer)
                                       
    Return the state of the controller status flags in the variable
    pointed to by DataPointer.  The contoller status flags include:
    Bit 0 = COMMAND_ERROR
    Bit 1 = -
    Bit 2 = ENCODER_SLIP
    Bit 3 = OVERTRAVEL_ERROR
    The controller status is acquired from the flags that are latched
    by the device driver.  When an error condition is detected the driver
    latches any flags that are on.  The application must then clear that
    flag once the error condition has been HANDLEd.  See the
    ClrOmsControllerStatusFlags function described below.
    
        
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int ControllerFlags;
    int Status;
    ...
    ...
    Status = GetOmsControllerFlags(Oms1Handle,
                                   &ControllerFlags);
    if(Status != SUCCESS)
    //Handle the error conditions
    else
      ...
      if((ControllerFlags & COMMAND_ERROR) != 0)
      //Handle command error
      ...

    Visual Basic Example:
    Dim ControllerFlags As Long
    Dim Status As Long
    ...
    ...
    Status = GetOmsControllerFlags(Oms1Handle, _
                                   ControllerFlags)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    Else
      ...
      If((ControllerFlags And COMMAND_ERROR) <> 0) Then
        'Handle Command Error
      ...

       
10.0 FUNCTIONS SPECIFIC TO ENCODER FEEDBACK SYSTEMS:
 
10.01 int Status = EnableOmsSlipDetection(HANDLE Oms1Handle,
                                          int AxisSelection)
 
    Enable slip detection for the selected encoder axis.
    Note slip detection is automatically disabled:
    - On controller power up or reset.
    - If any axis is driven into an overtravel limit.
    - If slip is detected on any encoder axis.
    - Any of the following functions are called:
      HomeAxis...
      SetOmsAxisPosition
      FindOmsAxisFwdLimit
      FindOmsAxisRevLimit
      KillAllOmsMotion
      StopOmsAxis
      StopAllOmsAxes
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT)

    "C" Example:
    int Status;
    ...
    ...
    Status = EnableOmsSlipDetection(Oms1Handle, OMS_Y_AXIS);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    ...
    ...
    Status = EnableOmsSlipDetection(Oms1Handle, OMS_Y_AXIS)
    If(Status <> SUCCESS) Then
     'Handle error condition

       
10.02 int Status = GetAllOmsSlipFlags(HANDLE Oms1Handle,  
                                      int *DataPointer)
                            
    Return the encoder slip flag status, of all of the axes, in the int
    variable pointed to by DataPointer.
    
    Status return codes:{SUCCESS,  COMMAND_TIME_OUT}
    

    "C" Example:
    int SlipFlags;
    int Status;
    ...
    ...
    Status = GetAllOmsSlipFlags(Oms1Handle,
                                &SlipFlags);
    if(Status <> SUCESS)
    //Handle error     
    else                       
      if((SlipFlags & (OMS_Y_AXIS)) != 0)
      //Handle Y axis encoder slip condition

    Visual Basic Example:
    Dim SlipFlags As Long
    Dim Status As Long
    ...
    ...
    Status = GetAllOmsSlipFlags(Oms1Handle, _
                                SlipFlags)
    If(Status <> SUCCESS) Then
      'Handle erorr
    Else                              
      If((SlipFlags And OMS_Y_AXIS) <> 0) Then
        'Handle Y axis encoder slip condition

       
10.03 int Status = GetOmsEncoderFlags(HANDLE Oms1Handle,  
                                      int AxisSelection,
                                      int *DataPointer)
                                      
    Return the state of the encoder status flags for the selected axis.  The
    status data is returned in the variable pointed to by DataPointer.
    Status byte format is as follows:


    
    Bit 0 - SLIP_DETECT_ENABLED          0=Disabled         1=Enabled
    Bit 1 - POSITION_MAINTENANCE_ENABLED 0=Disabled         1=Enabled
    Bit 2 - AXIS_SLIPPED                 0=No slip          1=Slip detected
    Bit 3 - AXIS_WITHIN_DEADBAND         0=Not in deadband  1=In deadband
    Bit 4 - ENCODER_AT_HOME              0=Not at home      1=At home
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, RESPONSE_TIME_OUT}

    "C" Example:
    int AxisSelection;
    int EncoderFlags;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = GetOmsEncoderFlags(Oms1Handle,
                                AxisSelection,
                                &EncoderFlags);
    if(Status != SUCCESS)
    //Handle the error conditions
    else
      ...
      //If slip detected
      if((EncoderFlags & AXIS_SLIPPED) != 0)
        //Handle encoder slip
      ...

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim EncoderFlags As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = GetOmsEncoderFlags(Oms1Handle, _
                                AxisSelection, _
                                EncoderFlags)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    Else
      ...
      'If slip detected
      If((EncoderFlags And AXIS_SLIPPED) <> 0) Then
        'Handle encoder slip

       
10.04 int Status = GetOmsAxisEncoderPosition(HANDLE Oms1Handle,
                                             int AxisSelection,
                                             long *PositionPointer)
                                             
    Return the current position count of the selected axis encoder.  The
    encoder position is returned in the long integer variable pointed to
    by PositionPointer.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT}

    "C" Example:
    int AxisSelection;
    long EncoderPosition;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = GetOmsAxisEncoderPosition(Oms1Handle,
                                       AxisSelection,
                                       &EncoderPosition);
    if(Status != SUCCESS)
      //Handle the error conditions
    else
      //Process encoder position
      
    Visual Basic Example:
    Dim AxisSelection As Long
    Dim EncoderPosition As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = GetOmsAxisEncoderPosition(Oms1Handle, _
                                       AxisSelection, _
                                       EncoderPosition)
    If(Status <> SUCCESS) Then
      'Handle the error conditions
    else
       'Process encoder position

       
10.05 int Status = SetOmsEncoderHoldMode(HANDLE Oms1Handle,
                                         int AxisSelection,
                                         int HoldMode)
                                         
    Set the encoder position hold mode of an axis to MODE_ON or MODE_OFF.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    int HoldMode;
    int Status;
    ...
    ...
    //Turn Y axis encoder position hold mode on
    AxisSelection = OMS_Y_AXIS;
    HoldMode = MODE_ON;
    Status = SetOmsEncoderHoldMode(Oms1Handle,
                                   AxisSelection,
                                   HoldMode);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim HoldMode As Long
    Dim Status As Long
    ...
    ...
    'Turn Y axis encoder position hold mode on
    AxisSelection = OMS_Y_AXIS
    HoldMode = MODE_ON
    Status = SetOmsEncoderHoldMode(Oms1Handle, _
                                   AxisSelection, _
                                   HoldMode)
    If(Status <> SUCCESS) Then
      'Handle error condition


 
10.06 int Status = SetOmsEncoderRatio(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      int EncoderCount.
                                      int MotorCount)
                                      
    Set the encoder count to motor count ratio of an axis.
    The function limits both the encoder count and the motor count to the range
    of 1 to 32000.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    int EncoderCount;
    int MotorCount;
    int Status;
    ...
    ...
    //Set encoder ratio for an axis whose motor moves 10 steps for
    //each encoder count.
    AxisSelection = OMS_Y_AXIS;
    EncoderCount = 1;
    MotorCount = 10:
    Status = SetOmsEncoderRatio(Oms1Handle,
                                AxisSelection,
                                EncoderCount,
                                MotorCount);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim EncoderCount As Long
    Dim MotorCount As Long
    Dim Status As Long
    ...
    ...
    'Set encoder ratio for an axis whose motor moves 10 steps for
    'each encoder count.
    AxisSelection = OMS_Y_AXIS
    EncoderCount = 1
    MotorCount = 10
    Status = SetOmsEncoderRatio(Oms1Handle, _
                                AxisSelection, _
                                EncoderCount, _
                                MotorCount)
    If(Status <> SUCCESS) Then
      'Handle error condition

 
10.07 int Status = SetOmsHoldDeadBand(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      int DeadBand)
                                      
    Set the hold dead band count of an axis.
    The function limits deadband to a range of 0 to 32000.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    int DeadBand;
    int Status;
    ...
    ...
    //Allow and encoder to move 5 counts before correcting axis position.
    AxisSelection = OMS_Y_AXIS;
    DeadBand = 5;
    Status = SetOmsHoldDeadBand(Oms1Handle,
                                AxisSelection,
                                DeadBand);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim DeadBand As Long
    Dim Status As Long
    ...
    ...
    'Allow and encoder to move 5 counts before correcting axis position.
    AxisSelection = OMS_Y_AXIS
    DeadBand = 5
    Status = SetOmsHoldDeadBand(Oms1Handle, _
                                AxisSelection, _
                                DeadBand)
    If(Status <> SUCCESS) Then
      'Handle error condition

 
10.08  int Status = SetOmsEncoderSlipTolerance(HANDLE Oms1Handle,
                                               int AxisSelection,
                                               int SlipTol)
                                               
    Set the encoder slip detection tolerance of an encoder axis.
    The function limits slip to a range of 0 to 32000.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    int SlipTol;
    int Status;
    ...
    ...
    //Allow an axis to slip 5 counts before declaring a slip condition.
    AxisSelection = OMS_Y_AXIS;
    SlipTol = 5:
    Status = SetOmsEncoderSlipTolerance(Oms1Handle,
                                        AxisSelection,
                                        SlipTol);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim SlipTol As Long
    Dim Status As Long
    ...
    ...
    'Allow an axis to slip 5 counts before declaring a slip condition.
    AxisSelection = OMS_Y_AXIS
    SlipTol = 5
    Status = SetOmsEncoderSlipTolerance(Oms1Handle, _
                                        AxisSelection, _
                                        SlipTol)
    if(Status <> SUCCESS) Then
      'Handle error condition



10.09 int Status = SetOmsHoldGain(HANDLE Oms1Handle,
                                  int AxisSelection,
                                  int HoldGain)
                                  
    Set an axis hold gain.  The gain is multiplied by position error to
    determine the correction velocity.  The parameter must be between 1 and 
    32000.
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    int HoldGain;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    HoldGain = 50;
    Status = SetOmsHoldGain(Oms1Handle,
                            AxisSelection,
                            HoldGain);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim HoldGain As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    HoldGain = 50
    Status = SetOmsHoldGain(Oms1Handle, _
                            AxisSelection, _
                            HoldGain)
    If(Status <> SUCCESS) Then
      'Handle error condition
                              

10.10 int Status = SetOmsHoldVelocity(HANDLE Oms1Handle,
                                      int AxisSelection,
                                      long HoldVelocity)
                                      
   Set the position hold velocity of an axis to lHoldVelocity.  This is the
   maximum velocity that will be used while correcting an axis position error.
   Velocity is limited to the range of 1 to 522000 steps per second.
        
   Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                        INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    long  HoldVelocity;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    HoldVelocity = 10000;
    Status = SetOmsHoldVelocity(Oms1Handle,
                                AxisSelection,
                                HoldVelocity);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim  HoldVelocity As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    HoldVelocity = 10000
    Status = SetOmsHoldVelocity(Oms1Handle, _
                                AxisSelection, _
                                HoldVelocity)
    If(Status <> SUCCESS) Then
      'Handle error condition

    
    
11. 0 FUNCTIONS THAT CONTROL HOW AXIS OVERTRAVEL IS HANDLED:
                              
11.01 int Status = SetOmsAxisOvertravelDetect(HANDLE Oms1Handle,
                                              int AxisSelection,
                                              int OvertravelDetect)
                                              
    Turn overtravel detection of an axis MODE_ON or MODE_OFF.
 
        
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, COMMAND_TIME_OUT,
                         INVALID_PARAMETER}

    "C" Example:
    int AxisSelection;
    int Status;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = SetOmsAxisOvertravelDetect(Oms1Handle,
                                        AxisSelection,
                                        MODE_ON);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim AxisSelection As Long
    Dim Status As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = SetOmsAxisOvertravelDetect(Oms1Handle, _
                                        AxisSelection, _
                                        MODE_ON)
    If(Status <> SUCCESS) Then
      'Handle error condition

                              
11.02 int Status = SetOmsSoftLimitsMode(HANDLE Oms1Handle,
                                        int SoftLimitMode)

    Turn the soft limit handling mode of all axes MODE_ON or MODE_OFF.  When the
    soft limit is on all axes will use the deceleration ramp to stop when an
    overtravel limit switch is activated.  If the soft limit is off then all
    axes will stop immeidately with out using a deceleration ramp.
 
        
    Status return codes:{SUCCESS, COMMAND_TIME_OUT, INVALID_PARAMETER}

    "C" Example:
    int Status;
    int AxisSelection;
    ...
    ...
    AxisSelection = OMS_Y_AXIS;
    Status = SetOmsSoftLimitsMode(Oms1Handle,
                                  MODE_ON);
    if(Status != SUCCESS)
    //Handle error condition

    Visual Basic Example:
    Dim Status As Long
    Dim AxisSelection As Long
    ...
    ...
    AxisSelection = OMS_Y_AXIS
    Status = SetOmsSoftLimitsMode(Oms1Handle, _
                                  MODE_ON)
    If(Status <> SUCCESS) Then
      'Handle error condition



12.0 GENERAL PURPOSE I/O BIT FUNCTIONS:                              

12.01 int Status = GetOmsIOBit(HANDLE Oms1Handle,
                               int BitNumber,
                               BOOL *StatePointer)
                               
    Get the current logical state of the selected general purpose input or
    output bit.  The state of the bit is returned in the boolean variable
    pointed to by StatePointer.  Bit numbers are limited to the range of
    0 to 13.  
        
    BitStateValues = {FALSE, TRUE}
    
    Status return codes:{SUCCESS, INVALID_BIT_NUMBER, COMMAND_TIME_OUT}
    
    
    "C" Example:
    int BitNumber;
    BOOL BitState;
    int Status;
    ...
    ...
    //Get the logical state of bit 0
    BitNumber = 0;
    Status = GetOmsIOBit(Oms1Handle,
                         BitNumber,
                         &BitState);
    if(Status != SUCCESS)
    //Handle error condition
    else
      if(BitState == TRUE)
      ...
    
    Visual Basic Example:
    Dim BitNumber As Long
    Dim BitState As Boolean
    Dim Status As Long
    ...
    ...
    'Get the logical state of bit 0
    BitNumber = 0
    Status = GetOmsIOBit(Oms1Handle, _
                         BitNumber, _
                         BitState)
    If(Status <> SUCCESS) Then
      'Handle error condition
    Else
      If(BitState = True) Then
      ...
                              

12.02 int Status = GetAllOmsIOBits(HANDLE Oms1Handle,
                                   int *StatePointer)
                                 
    Get the current state of all of the general purpose input and output bits.
    The logical states  of the bits are returned in the int integer variable
    pointed to by StatePointer.
    
    BitValues = {If bit is 0 state is FALSE
                 If bit is 1 state is TRUE}
        
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}
    

    "C" Example:
    int Status;
    int BitStates;
    ...
    ...
    Status = GetAllOmsIOBits(Oms1Handle,
                             &BitStates);
    if(Status != SUCCESS)
    //Handle error condition
    else
      //If bit zero is a logical true
      if((BitStates & BIT0) != 0)
      ...

    Visual Basic Example:
    Dim Status As Long
    Dim BitStates As Long
    ...
    ...
    Status = GetAllOmsIOBits(Oms1Handle, _
                             BitStates)
    If(Status <> SUCCESS) Then
      'Handle error condition
    Else
      'If bit zero is a logical true
      If((BitStates And BIT0) <> 0) Then
      ...
                              

12.03 int Status = GetOmsIOBitConfig(HANDLE Oms1Handle,
                                     int *ConfigPointer)
                                     
    Get the configuration of all of the general purpose input and output bits.
    The configuration of the bits are returned in the int integer variable
    pointed to by ConfigPointer.
    BitValues = {Input bits have bit = 0, Output bits have bit = 1}
        
    Status return codes:{SUCCESS, COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    int BitConfig;
    ...
    ...
    Status = GetOmsIOBitConfig(Oms1Handle,
                               &BitConfig);
    if(Status != SUCCESS)
    //Handle error condition
    else
      if((BitConfig & BIT8) != 0)
        //Bit eight is an output
      Else
        //Bit eight is an input

    Visual Basic Example:
    Dim Status As Long
    Dim BitConfig As Long
    ...
    ...
    Status = GetOmsIOBitConfig(Oms1Handle, _
                               BitConfig)
    If(Status <> SUCCESS) Then
      'Handle error condition
    else
      If((BitConfig And BIT8) <> 0) Then
        'Bit eight is an output
      Else
        'Bit eight is an input  
      ...
                              

12.04 int Status = SetOmsIOBit(HANDLE Oms1Handle,
                               int BitNumber,
                               BOOL BitStateValue)
                               
    Set the logical state of the selected general purpose output bit.  Bit
    numbers are limited to the range of 0 to 13.
        
    BitStateValues = {FALSE, TRUE}
    
    Status return codes:{SUCCESS, INVALID_BIT_NUMBER, INVALID_PARAMETER,
                         COMMAND_TIME_OUT}
    

    "C" Example:
    int BitNumber;
    BOOL BitState;
    int Status;
    ...
    ...
    //Set output bit 10 to a logic true 
    BitNumber = 10;
    BitState = TRUE;
    Status = SetOmsIOBit(Oms1Handle,
                         BitNumber,
                         BitState);
    if(Status != SUCCESS)
    //Handle error condition
      ...

    Visual Basic Example:
    Dim BitNumber As Long
    Dim BitState As Boolean
    Dim Status As Long
    ...
    ...
    'Set output bit 10 to a logic true 
    BitNumber = 10
    BitState = True
    Status = SetOmsIOBit(Oms1Handle, _
                         BitNumber, _
                         BitState)
    If(Status <> SUCCESS) Then
      'Handle error condition
      ...



13.0  AXIS AUXILIARY OUTPUT BIT FUNCTIONS:                              

13.01 int Status = EnableOmsAxisAuxOutAutoMode(HANDLE Oms1Handle,
                                               int AxisSelection,
                                               BOOL BitStateValue)
                                               
    Enable the automatic activation of the axis auxililary output bit while
    the axis is in motion.  Define the in motion state of the bit to be equal
    to the BitStateValue.  Note this automatic bit activation mode is disabled
    if the board is reset or the state of the auxiliary output bit is set via
    either the SetOmsAxisAuxOutBit or the SetSelectedOmsAuxOutBits functions.
    
    BitStateValues = {FALSE, TRUE}
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, INVALID_PARAMETER,
                         COMMAND_TIME_OUT}
    

    "C" Example:
    int Status;
    int AxisSelection;
    BOOL AuxState;
    ...
    ...
    //Set the mode of the Y axis auxilary bit so that it will be set to
    //the TRUE state while the Y axis is moving and FALSE when it is stopped.
    AxisSelection = OMS_Y_AXIS;
    AuxState = TRUE;
    Status = EnableOmsAxisAuxOutAutoMode(Oms1Handle,
                                         AxisSelection,
                                         AuxState);
    if(Status != SUCCESS)
    //Handle error condition
      ...

    Visual Basic Example:
    Dim Status As Long
    Dim AxisSelection As Long
    Dim AuxState As Boolean
    ...
    ...
    'Set the mode of the Y axis auxilary bit so that it will be set to
    'the TRUE state while the Y axis is moving and FALSE when it is stopped.
    AxisSelection = OMS_Y_AXIS
    AuxState = True
    Status = EnableOmsAxisAuxOutAutoMode(Oms1Handle, _
                                         AxisSelection, _
                                         AuxState)
    If(Status <> SUCCESS) Then
     'Handle error condition
      ...


13.02 int Status = SetOmsAxisAuxOutBit(HANDLE Oms1Handle,
                                       int AxisSelection,
                                       BOOL BitStateValue)
                                       
    Set the logical state of the axis auxiliary output bit and
    disable the automatic activation of this bit when the axis is in motion.
        
    BitStateValues = {FALSE, TRUE}
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, INVALID_PARAMETER,
                         COMMAND_TIME_OUT}

    "C" Example:
    int Status;
    int AxisSelection;
    BOOL AuxState;
    ...
    ...
    //Set the Y axis auxilary output bit to a TRUE state 
    Status = SetOmsAxisAuxOutBit(Oms1Handle,
                                 OMS_Y_AXIS,
                                 TRUE);
    if(Status != SUCCESS)
    //Handle error condition
      ...

    Visual Basic Example:
    Dim Status As Long
    Dim AxisSelection As Long
    Dim AuxState As Boolean
    ...
    ...
    'Set the Y axis auxilary output bit to a TRUE state 
    AxisSelection = OMS_Y_AXIS
    AuxState = True
    Status = SetOmsAxisAuxOutBit(Oms1Handle, _
                                 AxisSelection, _
                                 AuxState)
    If(Status <> SUCCESS) Then
      'Handle error condition
      ...
                              

13.03 int Status = SetOmsAxisAuxOutSettleTime(HANDLE Oms1Handle,
                                              int AxisSelection,
                                              int SettleTime)
                                              
    Set the settling time of an axis auxiliary output bit.  This is the number
    of milliseconds that the bit is left active after the axis has finished a
    move.
    
    The settling time must be between 0 and 1000 milliseconds.
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, INVALID_PARAMETER,
                         COMMAND_TIME_OUT}
 
    "C" Example:
    int Status;
    int AxisSelection;
    int SettleTime;
    ...
    ...
    //Set the Y axis settling time to 100 milliseconds.
    AxisSelection = OMS_Y_AXIS;
    SettleTime = 100;
    Status = SetOmsAxisAuxOutSettleTime(Oms1Handle,
                                        AxisSelection,
                                        SettleTime);
    if(Status != SUCCESS)
    //Handle error condition
      ...
 
    Visual Basic Example:
    Dim Status As Long
    Dim AxisSelection As Long
    Dim SettleTime As Long
    ...
    ...
    'Set the Y axis settling time to 100 milliseconds.
    AxisSelection = OMS_Y_AXIS
    SettleTime = 100
    Status = SetOmsAxisAuxOutSettleTime(Oms1Handle, _
                                        AxisSelection, _
                                        SettleTime)
    If(Status <> SUCCESS) Then
      'Handle error condition
      ...
                              

13.04 int Status = SetSelectedOmsAuxOutBits(HANDLE Oms1Handle,
                                            int AxisSelections,
                                            BOOL BitStateValue)
                                            
    Set the logical state of the selected axis auxiliary output bits and
    disable the automatic activation of these bits when the axes are in motion.
    
        
    BitStateValues = {FALSE, TRUE}
    
    Status return codes:{SUCCESS, INVALID_AXIS_SELECTION, INVALID_PARAMETER,
                         COMMAND_TIME_OUT}
 
    "C" Example:
    int Status;
    int AxisSelection;
    BOOL AuxState;
    ...
    ...
    //Set the X & Y axis auxilary output bits to a TRUE state 
    AxisSelection = OMS_X_AXIS | OMS_Y_AXIS;
    AuxState = TRUE;
    Status = SetSelectedOmsAuxOutBits(Oms1Handle,
                                      AxisSelection,
                                      AuxState);
    if(Status != SUCCESS)
    //Handle error condition
      ...
 
    Visual Basic Example:
    Dim Status As Long
    Dim AxisSelection As Long
    Dim AuxState As Boolean
    ...
    ...
    'Set the X & Y axis auxilary output bits to a TRUE state 
    AxisSelection = OMS_X_AXIS + OMS_Y_AXIS
    AuxState = TRUE
    Status = SetSelectedOmsAuxOutBits(Oms1Handle, _
                                      AxisSelection, _
                                      AuxState)
    If(Status <> SUCCESS) Then
      'Handle error condition
      ...
      
14.0 TIME DELAY FUNCTION      
      
14.01 int Status = OmsWait(int WaitTime)
                                            
    Block the thread for the specified number of millseconds.  The function
    calls the Microsoft SDK Sleep function directly.  Note time resolution
    depends on the PC's timer tick resolution.  This is typically about 10
    milliseconds.
        
    Wait Time Values = {0 -         Release the remainder of the thread's time
                                    slice.
                        1 - 3600000 Block the thread for the specified number of
                                    milliseconds} 
    
    Status return codes:{SUCCESS, INVALID_PARAMETER}
 
    "C" Example:
    int Status;
    long WaitTime;
    ...
    ...
    //Block the thread for 1 second
    WaitTime = 1000;
    Status = OmsWait(WaitTime);
    if(Status != SUCCESS)
    //Handle error condition
      ...
 
    Visual Basic Example:
    Dim Status As Long
    Dim WaitTime As Long
    ...
    ...
    'Block the thread for 1 second
    WaitTime = 1000
    Status = OmsWait(WaitTime)
    if(Status <> SUCCESS) Then
      'Handle error condition
      ...


Function Index:

CloseOmsHandle....................1.02
ClrOmsControllerFlags.............9.01
ClrOmsDoneFlags...................9.02
DefineOmsHomeAsSwitchClosed.......6.01
DefineOmsHomeAsSwitchOpen.........6.02
EnableOmsAxisAuxOutAutoMode......13.01
EnableOmsSlipDetection...........10.01
FindOmsAxisFwdLimit...............6.03
FindOmsAxisRevLimit...............6.04
GetAllOmsDoneFlags................9.03
GetAllOmsIOBits..................12.02
GetAllOmsSlipFlags...............10.02
GetOmsAxisAcceleration............8.01
GetOmsAxisDoneFlag................9.04
GetOmsAxisEncoderPosition........10.04
GetOmsAxisFlags...................9.05
GetOmsAxisMotorPosition...........5.01
GetOmsAxisVelocity................7.01
GetOmsControllerDescription.......9.06
GetOmsControllerFlags.............9.07
GetOmsEncoderFlags...............10.03
GetOmsHandle......................1.01
GetOmsIOBit......................12.01
GetOmsIOBitConfig................12.03
GetSelectedOmsAccelerations.......8.02
GetSelectedOmsVelocities..........7.02
GetSelectedOmsMotorPositions......5.02
HomeOmsAxisFwdUseEncoder..........6.05
HomeOmsAxisFwdUseEncoderWait......6.06
HomeOmsAxisFwdUseSwitch...........6.07
HomeOmsAxisFwdUseSwitchWait.......6.08
HomeOmsAxisRevUseEncoder..........6.09
HomeOmsAxisRevUseEncoderWait......6.10
HomeOmsAxisRevUseSwitch...........6.11
HomeOmsAxisRevUseSwitchWait.......6.12
KillAllOmsMotion..................3.09
MoveOmsAxisAbs....................2.01
MoveOmsAxisAbsWait................2.02
MoveOmsAxisIndefinite.............2.03
MoveOmsAxisFractional.............2.04
MoveOmsAxisRel....................2.05
MoveOmsAxisRelWait................2.06
MoveOmsAxisOneStep................2.07
StopOmsAxis.......................2.08
MoveOmsIndependantAbs.............3.01
MoveOmsIndependantAbsMt...........4.01
MoveOmsIndependantAbsMtWait.......4.02
MoveOmsIndependantAbsWait.........3.02
MoveOmsIndependantRel.............3.03
MoveOmsIndependantRelMt...........4.03
MoveOmsIndependantRelMtWait.......4.04
MoveOmsIndependantRelWait.........3.04
MoveOmsLinearAbs..................3.05
MoveOmsLinearAbsMt................4.05
MoveOmsLinearAbsMtWait............4.06
MoveOmsLinearAbsWait..............3.06
MoveOmsLinearRel..................3.07
MoveOmsLinearRelMt................4.07
MoveOmsLinearRelMtWait............4.08
MoveOmsLinearRelWait..............3.08
OmsWait..........................14.01
ResetOmsController................1.03
SelectOmsCosineRamp...............8.03
SelectOmsLinearRamp...............8.04
SelectOmsParabolicRamp............8.05
SendOmsQueryCommand...............1.04
SendOmsTextCommand................1.05
SetOmsAxisBaseVelocity............7.03
SetOmsAxisOvertravelDetect.......11.01
SetOmsAxisPosition................6.13
SetOmsAxisVelocity................7.04
StopAllOmsAxes....................3.10
SetOmsAxisAcceleration............8.06
SetOmsAxisAuxOutBit..............13.02
SetOmsAxisAuxOutSettleTime.......13.03
SetOmsEncoderHoldMode............10.05
SetOmsEncoderRatio...............10.06
SetOmsEncoderSlipTolerance.......10.08
SetOmsHoldDeadBand...............10.07
SetOmsHoldGain...................10.09
SetOmsHoldVelocity...............10.10
SetOmsIOBit......................12.04
SetOmsSoftLimitsMode.............11.02
SetSelectedOmsAuxOutBits.........13.04

