Motion.java

Go to the documentation of this file.

// -----------------------------------------------------------------------
// MLPI - <Motion.java>
// -----------------------------------------------------------------------
// Copyright (c) 2012 Bosch Rexroth. All rights reserved.
// Redistribution and use in source and binary forms of this MLPI software
// (SW) provided to you, with or without modification, are permitted
// without prior approval provided that the following conditions are met:
//
// 1. Redistributions of source code of SW must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form of SW must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. User recognizes and acknowledges that it acquires no right,
// title or interest in or to any of the names or trademarks used in
// connection with the SW ("names") by virtue of this License and waives
// any right to or interest in the names. User recognizes and acknowledges
// that names of companies or names or products of companies displayed
// in the documentation of SW to indicate the interoperability of products
// with the SW are the names of their respective owners. The use of such
// names in the documentation of SW does not imply any sponsorship,
// approval, or endorsement by such companies of this product.
//
// 4. Modified code versions, i.e. any addition to or deletion from
// the substance or structure of the original code of the SW running
// the MLPI must be plainly marked as such and must not be misrepresented
// as being original SW.
//
// 5. The SW may only be used in connection with a Bosch Rexroth product.
//
// THIS INFORMATION IS PROVIDED BY BOSCH REXROTH CORPORATION "AS IS"
// AND WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING
// (BUT NOTLIMITED TO) ANY IMPLIED WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR ANY PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WHILE THE
// INFORMATION PROVIDED IS BELIEVED TO BE ACCURATE, IT MAY INCLUDE
// ERRORS OR INACCURACIES.
// SUBJECT TO COMPULSORY STATUTORY PROVISIONS OF THE GERMAN LAW AS
// THE APPLICABLE LAW FOR THIS LICENSE BOSCH REXROTH CORPORATION WILL
// NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING FROM THE USE OF
// THE  SOFTWARE  DISTRIBUTED HEREUNDER, INCLUDING BUT NOT LIMITED TO
// DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, AND CONSEQUENTIAL DAMAGES.
// -----------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------
package com.boschrexroth.mlpi;

import java.util.Vector;


public class Motion extends MlpiComponent {
  /*
   * Enums
   */
  public enum AxisType
  {
    AXISTYPE_VIRTUAL      (0),
    AXISTYPE_REAL         (1),
    AXISTYPE_ENCODER      (2),
    AXISTYPE_LINK         (3),
    AXISTYPE_CONTROLLER   (4);

    private int _code;
    int getCode() { return _code; }
    AxisType(int code) { this._code = code; }
    static AxisType valueOf(int code) {
      for (AxisType value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum SyncDirection
  {
    SYNC_SHORTESTWAY  (0),
    SYNC_CATCHUP      (1),
    SYNC_SLOWDOWN     (2);

    private int _code;
    int getCode() { return _code; }
    SyncDirection(int code) { this._code = code; }
    static SyncDirection valueOf(int code) {
      for (SyncDirection value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum SyncType
  {
    SYNC_RAMPIN_SHORTESTWAY  (0),
    SYNC_RAMPIN_CATCHUP      (1),
    SYNC_RAMPIN_SLOWDOWN     (2),
    SYNC_DIRECT              (3);

    private int _code;
    int getCode() { return _code; }
    SyncType(int code) { this._code = code; }
    static SyncType valueOf(int code) {
      for (SyncType value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum StartMode
  {
    STARTMODE_ABSOLUTE        (0),
    STARTMODE_RELATIVE        (1),
    STARTMODE_ABSOLUTE_RAMPIN (2),
    STARTMODE_RELATIVE_RAMPIN (3);

    private int _code;
    int getCode() { return _code; }
    StartMode(int code) { this._code = code; }
    static StartMode valueOf(int code) {
      for (StartMode value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum ProfileExecutionMode
  {
    EXECUTE_CYCLIC (0),
    EXECUTE_SINGLE (1);

    private int _code;
    int getCode() { return _code; }
    ProfileExecutionMode(int code) { this._code = code; }
    static ProfileExecutionMode valueOf(int code) {
      for (ProfileExecutionMode value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum ProfileStartPoint
  {
    SLAVE_ORIGIN_MASTER_ORIGIN    (0),
    SLAVE_CURRENT_MASTER_CURRENT  (1),
    SLAVE_ORIGIN_MASTER_CURRENT   (2),
    SLAVE_CURRENT_MASTER_ORIGIN   (3),
  SLAVE_RELATIVE_MASTER_ORIGIN  (4);

    private int _code;
    int getCode() { return _code; }
    ProfileStartPoint(int code) { this._code = code; }
    static ProfileStartPoint valueOf(int code) {
      for (ProfileStartPoint value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum AxisMode
  {
    AXIS_MODE_ACTIVE                                (0),
    AXIS_MODE_PARKING                               (1),
    AXIS_MODE_DEACTIVATED                           (2),
    AXIS_MODE_ACTIVE_DECOUPLED                      (3),
    AXIS_MODE_PARKING_DECOUPLED                     (4),
    AXIS_MODE_DEACTIVATED_DECOUPLED                 (5),
    AXIS_MODE_ACTIVE_PARAMETERIZATION               (8),
    AXIS_MODE_PARKING_PARAMETERIZATION              (9),
    AXIS_MODE_DEACTIVATED_PARAMETERIZATION          (10),
    AXIS_MODE_ACTIVE_DECOUPLED_PARAMETERIZATION     (12),
    AXIS_MODE_PARKING_DECOUPLED_PARAMETERIZATION    (13),
    AXIS_MODE_DEACTIVATED_DECOUPLED_PARAMETERIZATION(14);

    private int _code;
    int getCode() { return _code; }
    AxisMode(int code) { this._code = code; }
    static AxisMode valueOf(int code) {
      for (AxisMode value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  public enum CamTableId
  {
    CAM_TABLE_1   (1),
    CAM_TABLE_2   (2),
    CAM_TABLE_3   (3),
    CAM_TABLE_4   (4),
    CAM_TABLE_5   (5),
    CAM_TABLE_6   (6),
    CAM_TABLE_7   (7),
    CAM_TABLE_8   (8),
    CAM_TABLE_9   (9),
    CAM_TABLE_10  (10),
    CAM_TABLE_11  (11),
    CAM_TABLE_12  (12),
    CAM_TABLE_13  (13),
    CAM_TABLE_14  (14),
    CAM_TABLE_15  (15),
    CAM_TABLE_16  (16),
    CAM_TABLE_17  (17),
    CAM_TABLE_18  (18),
    CAM_TABLE_19  (19),
    CAM_TABLE_20  (20),
    CAM_TABLE_21  (21),
    CAM_TABLE_22  (22),
    CAM_TABLE_23  (23),
    CAM_TABLE_24  (24),
    CAM_TABLE_25  (25),
    CAM_TABLE_26  (26),
    CAM_TABLE_27  (27),
    CAM_TABLE_28  (28),
    CAM_TABLE_29  (29),
    CAM_TABLE_30  (30),
    CAM_TABLE_31  (31),
    CAM_TABLE_32  (32),
    CAM_TABLE_33  (33),
    CAM_TABLE_34  (34),
    CAM_TABLE_35  (35),
    CAM_TABLE_36  (36),
    CAM_TABLE_37  (37),
    CAM_TABLE_38  (38),
    CAM_TABLE_39  (39),
    CAM_TABLE_40  (40),
    CAM_TABLE_41  (41),
    CAM_TABLE_42  (42),
    CAM_TABLE_43  (43),
    CAM_TABLE_44  (44),
    CAM_TABLE_45  (45),
    CAM_TABLE_46  (46),
    CAM_TABLE_47  (47),
    CAM_TABLE_48  (48),
    CAM_TABLE_49  (49),
    CAM_TABLE_50  (50),
    CAM_TABLE_51  (51),
    CAM_TABLE_52  (52),
    CAM_TABLE_53  (53),
    CAM_TABLE_54  (54),
    CAM_TABLE_55  (55),
    CAM_TABLE_56  (56),
    CAM_TABLE_57  (57),
    CAM_TABLE_58  (58),
    CAM_TABLE_59  (59),
    CAM_TABLE_60  (60),
    CAM_TABLE_61  (61),
    CAM_TABLE_62  (62),
    CAM_TABLE_63  (63),
    CAM_TABLE_64  (64),
    CAM_TABLE_65  (65),
    CAM_TABLE_66  (66),
    CAM_TABLE_67  (67),
    CAM_TABLE_68  (68),
    CAM_TABLE_69  (69),
    CAM_TABLE_70  (70),
    CAM_TABLE_71  (71),
    CAM_TABLE_72  (72),
    CAM_TABLE_73  (73),
    CAM_TABLE_74  (74),
    CAM_TABLE_75  (75),
    CAM_TABLE_76  (76),
    CAM_TABLE_77  (77),
    CAM_TABLE_78  (78),
    CAM_TABLE_79  (79),
    CAM_TABLE_80  (80),
    CAM_TABLE_81  (81),
    CAM_TABLE_82  (82),
    CAM_TABLE_83  (83),
    CAM_TABLE_84  (84),
    CAM_TABLE_85  (85),
    CAM_TABLE_86  (86),
    CAM_TABLE_87  (87),
    CAM_TABLE_88  (88),
    CAM_TABLE_89  (89),
    CAM_TABLE_90  (90),
    CAM_TABLE_91  (91),
    CAM_TABLE_92  (92),
    CAM_TABLE_93  (93),
    CAM_TABLE_94  (94),
    CAM_TABLE_95  (95),
    CAM_TABLE_96  (96),
    CAM_TABLE_97  (97),
    CAM_TABLE_98  (98),
    CAM_TABLE_99  (99),
    CAM_TABLE_100 (100);

    private int _code;
    int getCode() { return _code; }
    CamTableId(int code) { this._code = code; }
    static CamTableId valueOf(int code) {
      for (CamTableId value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }

  /*
   * Structs
   */
  public static class AxisRef
  {
    public AxisRef(int axisNo) {
      this.axisNo = (short) axisNo;
      this.controlNo = 0;
    }
    public AxisRef(short axisNo) {
      this.axisNo = axisNo;
      this.controlNo = 0;
    }
    public AxisRef(int controlNo, int axisNo) {
      this.axisNo = (short) axisNo;
      this.controlNo = (short) controlNo;
    }
    public AxisRef(short controlNo, short axisNo) {
      this.axisNo = axisNo;
      this.controlNo = controlNo;
    }
    public short   controlNo;
    public short   axisNo;
  }

  public static class AxisInformation
  {
    public AxisRef  axis = new AxisRef(0);
    public int      deviceAddress;
    public AxisType axisType;
    public String   name;
  }

  public static class AxisValues
  {
    public double    actualPosition;
    public double    actualVelocity;
    public double    actualAcceleration;
    public double    actualTorque;
    public int       state;
    public int       stateExtended;
    public int       diagnosisNumber;
    public int       condition;
  }

  public static class AxisUnits
  {
    public String position;
    public String velocity;
    public String acceleration;
    public String jerk;
    public String torque;
  }
  
  public static class AxisStatus
  {
    public long      state;
    public int       stateExtended;
    public int       diagnosisNumber;
    public int       condition;
  }
  /*
   * Fields
   */
  Vector<Axis> _axes = new Vector<Axis>();

  /*
   * Methods
   */
  Motion(MlpiHandle connection) {
    super(connection);
  }
  
  public Axis axes(short axisNo) {
    return axes((int)axisNo);
  }
  public synchronized Axis axes(int axisNo) {
    Axis axis = null;
    if (axisNo > 0) {
      if (axisNo <= _axes.size()) {
        axis = _axes.get(axisNo-1);
      }
      if (axis == null) {
        axis = new Axis(getConnectionHandleObject(), new AxisRef(axisNo));
        if (axisNo > _axes.size()) {
          for (int i=_axes.size(); i<axisNo; i++){
            _axes.add(null);
          }
        }
        _axes.set(axisNo-1, axis);
      }      
    }
    else {
      throw new RuntimeException("Logical axis number '" + axisNo + "' out of minimum range.");
    }
    return axis;
  }
  
  public native AxisInformation[] getConfiguredAxes();
  
  public native AxisValues[] getAxisValues(AxisRef[] axes);
  
  public native AxisUnits[] getAxisUnits(AxisRef[] axes);
  
  public native AxisStatus[] getAxisStatus(AxisRef[] axes);
}