Robot.java

Go to the documentation of this file.

// -----------------------------------------------------------------------
// MLPI - <Robot.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;
import com.boschrexroth.mlpi.Motion.AxisRef;
import com.boschrexroth.mlpi.GroupInfo;

public class Robot extends MlpiComponent {

  public enum RobotAxisTypes
  {
    ROBOT_AXISTYPE_NONE        ( 0),  
    ROBOT_AXISTYPE_POSITIONING ( 8),  
    ROBOT_AXISTYPE_ORIENTATION (16),  
    ROBOT_AXISTYPE_BELT        (32);  

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

  public enum RobotTypes
  {
    ROBOT_TYPE_RHO      (1),
    ROBOT_TYPE_RCF      (2);

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

  public enum RobotSetMode
  {
    ROBOT_SETMODE_TO      (0),
    ROBOT_SETMODE_VIA     (1);

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

  public enum RobotCoordinateSystem
  {

    ROBOT_CS_MCS   (0x0000),
    ROBOT_CS_ACS   (0x0001),
    ROBOT_CS_BCS   (0x0002),
    ROBOT_CS_PCS1  (0x0003),
    ROBOT_CS_PCS2  (0x0103),
    ROBOT_CS_PCS3  (0x0203),
    ROBOT_CS_PCS4  (0x0303),
    ROBOT_CS_PCS5  (0x0403),
    ROBOT_CS_PCS6  (0x0503),
    ROBOT_CS_PCS7  (0x0603),
    ROBOT_CS_PCS8  (0x0703),
    ROBOT_CS_PCS9  (0x0803),
    ROBOT_CS_PCS10 (0x0903),
    ROBOT_CS_PCS11 (0x0A03),
    ROBOT_CS_PCS12 (0x0B03),
    ROBOT_CS_PCS13 (0x0C03),
    ROBOT_CS_PCS14 (0x0D03),
    ROBOT_CS_PCS15 (0x0E03),
    ROBOT_CS_PCS16 (0x0F03),
    ROBOT_CS_FCS   (0x0004);

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

  public enum RobotSlopeType
  {
    ROBOT_SLOPETYPE_BLOCK_SLOPE   (0),
    ROBOT_SLOPETYPE_PROGR_SLOPE   (1),
    ROBOT_SLOPETYPE_CONT_SLOPE    (2);


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

  public enum RobotSyncErrorReactionMode
  {
    ROBOT_BELT_ERROR_NO_SPECIFIC_REACTION      (0),
    ROBOT_BELT_ERROR_DESYNC_OVER_TIME          (1),
    ROBOT_BELT_ERROR_DESYNC_WITH_LIMITS        (2);


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

  public enum RobotMechCmd
  {
    ROBOT_MECH_CREATE_ROD      (0),
    ROBOT_MECH_CREATE_SPHERE   (1),
    ROBOT_MECH_POSITION        (2),
    ROBOT_MECH_DIRECTION       (3),
    ROBOT_MECH_SIZE            (4),
    ROBOT_MECH_CREATE_CUBOID   (5),
    ROBOT_MECH_SET_MCS         (6),
    ROBOT_MECH_ROTATE          (7);

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

  public enum RobotCSType{
    ROBOT_CARTESIAN (0),
    ROBOT_CYLINDRIC (1);

    private int _code;
    int getCode() { return _code; }
    RobotCSType(int code) { this._code = code; }
    static RobotCSType valueOf(int code) {
      for (RobotCSType value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }
  
  public enum RobotCyclicMode
  {
    ROBOT_CYCLIC_MODE_POS_ABS   (0),
    ROBOT_CYCLIC_MODE_POS_REL   (1),
    ROBOT_CYCLIC_MODE_VEL       (2);


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

  public enum RobotSafeZoneType{
    ROBOT_SAFE_ZONE_TYPE_DEACTIVATED (0),
    ROBOT_SAFE_ZONE_TYPE_INSIDE_OK   (1),
    ROBOT_SAFE_ZONE_TYPE_OUTSIDE_OK  (2);

    private int _code;
    int getCode() { return _code; }
    RobotSafeZoneType(int code) { this._code = code; }
    static RobotSafeZoneType valueOf(int code) {
      for (RobotSafeZoneType value : values()) {
        if (code == value.getCode()) return value;
      }
      return null;
    }
  }
  
  public enum RobotCmdInfoType
  {
    MLPI_ROBOT_CMD_INFO_TYPE_ALL              (0),
    MLPI_ROBOT_CMD_DATA_TYPE_PROGRESS         (1),
    MLPI_ROBOT_CMD_DATA_TYPE_TOTAL_DISTANCE   (2),
    MLPI_ROBOT_CMD_DATA_TYPE_UID              (3),
    MLPI_ROBOT_CMD_DATA_TYPE_STATE            (4);

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

  /*
   * Structs
   */

  public static class RobotTrafoParameter{
    public RobotTrafoParameter(){}

    public RobotTrafoParameter(Robot.RobotCoordinateSystem coordSys, double posX, double posY, double posZ, double rotA, double rotB, double rotC, RobotCSType csType){
      this.coordSys = coordSys;
      this.posX = posX;
      this.posY = posY;
      this.posZ = posZ;
      this.rotA = rotA;
      this.rotB = rotB;
      this.rotC = rotC;
      this.csType = csType;
    }

    public Robot.RobotCoordinateSystem coordSys;  //tbd JUR: wie muss hier die Datentypdeklaration realisiert werden innerhalb von Java?
    public double posX;
    public double posY;
    public double posZ;
    public double rotA;
    public double rotB;
    public double rotC;
    public RobotCSType csType;
  }

  public static class RobotBeltConfigValues{
    public RobotBeltConfigValues(){}

    public RobotBeltConfigValues(double posX, double posY, double posZ, double rotA, double rotB, double rotC, double begin, double total, RobotCSType csType){

      this.posX = posX;
      this.posY = posY;
      this.posZ = posZ;
      this.rotA = rotA;
      this.rotB = rotB;
      this.rotC = rotC;
      this.begin = begin;
      this.total = total;
      this.csType = csType;
    }

    public double posX;
    public double posY;
    public double posZ;
    public double rotA;
    public double rotB;
    public double rotC;
    public double begin;
    public double total;
    public RobotCSType csType;
  }

  public static class RobotBeltErrorReactionValues{
    public RobotBeltErrorReactionValues(){}

    public RobotBeltErrorReactionValues(RobotSyncErrorReactionMode errorType, double time, double deceleration, double jerk)
    {
      this.time = time;
      this.deceleration = deceleration;
      this.jerk = jerk;
      this.errorType = errorType;
    }

    public RobotSyncErrorReactionMode errorType;
    public double time;
    public double deceleration;
    public double jerk;

  }
  
  public static class GroupRef
  {
    public GroupRef(int groupNo) {
      this.groupNo = (short)groupNo;
      this.controlNo = 0;
    }
    public GroupRef(short groupNo) {
      this.groupNo = groupNo;
      this.controlNo = 0;
    }
    public short   controlNo;
    public short   groupNo;
  }

  public static class RobotInformation
  {
  public RobotInformation(GroupRef group, RobotTypes robotType, String name){
    this.group = group;
    this.robotType = robotType;
    this.name = name;
  }
  public RobotInformation(){}

    public GroupRef group = new GroupRef(0);
    public RobotTypes robotType;
    public String name;
  }

  public static class RobotPerformanceResult
  {
  public RobotPerformanceResult(String name, long count, double min, double max, double avg){
    this.name = name;
    this.count = count;
    this.min = min;
    this.max = max;
    this.avg = avg;
  }
  public RobotPerformanceResult(){}

    public String   name;
    public long     count;
    public double   min;
    public double   max;
    public double   avg;
  }

  public static class RobotMechanicData
  {
  public RobotMechanicData(RobotMechCmd cmd, String object, double x, double y, double z){
    this.cmd = cmd;
    this.object = object;
    this.x = x;
    this.y = y;
    this.z = z;
  }
  public RobotMechanicData(){}

    public RobotMechCmd cmd;
    public String object;
    public double x;
    public double y;
    public double z;
  }
  
  public static class RobotAxisConfiguration
  {
  public RobotAxisConfiguration(short axisConfiguration, short controlNumber, short axisNumber){
    this.axisConfiguration = axisConfiguration;
    this.controlNumber = controlNumber;
    this.axisNumber = axisNumber;
  }
  public RobotAxisConfiguration(){}

    public short axisConfiguration;
    public short controlNumber;
    public short axisNumber;
  };

  public static class RobotKinematicsValues
  {
    public RobotPoint    actualPosition;
    public double        actualVelocity;
    public double        actualAcceleration;
    public int           state;
    public int           stateExtended;
    public int           diagnosisNumber;
  }
  
  public static class RobotKinematicsUnits
  {
    public String position;
    public String velocity;
    public String acceleration;
  }
  
  public static class RobotCoordinateSystemInfo
  {
    public int cs;
    public int dimension;
    public String name;
    public String posunits;
  }
  
  public static class RobotStatusSummary
  {
      public GroupRef group;
    public int coordSys;                   // tbd: eigentlich muss hier Robot.RobotCoordinateSystem genutzt werden
    public int state;
    public int stateExtended;
    public int diagnosisNumber;
    public int dimension;
    public RobotPoint actualPosition;
    public String actualPosUnit;
    public double actualVelocity;
    public double actualAcceleration;
    public double actualJerk;
    public String pathUnit;
    public String timeBase;
  }
  
  
  public static class RobotStatusSummaryIn
  {
  public RobotStatusSummaryIn(GroupRef group, int coordSys){
      this.group = group;
    this.coordSys = coordSys;
  }
  public RobotStatusSummaryIn(){}
      public GroupRef group = new GroupRef(0);
    public int coordSys;
  }
  
  
  public static class RobotSafeZoneData
  {
    public double zoneNumber;
    
    public double pointPosX;
    public double pointPosY;
    public double pointPosZ;
    
    public double pointNegX;
    public double pointNegY;
    public double pointNegZ;
    
    public Robot.RobotSafeZoneType zoneType;
    

  }
    
  public static class RobotMotionHandle
  {
  public RobotMotionHandle(long cmdID){
      this.cmdID = cmdID;
  }
  public RobotMotionHandle(){}
      public long cmdID;
  }
  
  public static class RobotCmdInfo
  {
  public RobotCmdInfo(long commandID, RobotCmdInfoType infoType, double value){
    this.commandID = commandID;
    this.infoType = infoType;
    this.value = value;
  }
  public RobotCmdInfo(){}
    public long commandID;
    public RobotCmdInfoType infoType;
    public double value;
  }
  /*
   * Fields
   */
  Vector<Group> _groups = new Vector<Group>();

  /*
   * Methods
   */
   
  Robot(MlpiHandle connection) {
    super(connection);
  }

  public Group groups(short groupNo) {
     return groups((int)groupNo);
  }

  public synchronized Group groups(int groupNo) {
    Group group = null;
    if (groupNo <= _groups.size()) {
      group = _groups.get(groupNo-1);
    }
    if (group == null) {
      group = new Group(getConnectionHandleObject(), new GroupRef(groupNo));
      if (groupNo > _groups.size()) {
        for (int i=_groups.size(); i<groupNo; i++){
          _groups.add(null);
        }
      }
      _groups.set(groupNo-1, group);
    }
    return group;
  }

  public RobotPoint CreatePoint( double point[], Robot.RobotCoordinateSystem type){
    return new RobotPoint(point, type);
  }

  public native RobotInformation[] GetConfiguredGroups(); 
  
  public native RobotKinematicsValues[] GetKinematicsValues(GroupRef[] groups);
  
  public native RobotKinematicsUnits[] GetKinematicsUnits(GroupRef[] groups);
  
  public native RobotStatusSummary[] GetStatusSummary(RobotStatusSummaryIn[] statusSummaryIn);
}