Logic.java

Go to the documentation of this file.

// -----------------------------------------------------------------------
// MLPI - <Logic.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;

public class Logic extends MlpiComponent {
  /*
   * Constants
   */
  public static final int LOGIC_MAX_DIMENSION_OF_ARRAY = 3;

  /*
   * Enums
   */
  public enum ApplicationState
  {
    STATE_NONE(0),
    STATE_RUN(1),
    STATE_STOP(2),
    STATE_BP(3);

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

  public enum ApplicationResetMode
  {
    RESET_WARM(0),
    RESET_COLD(1),
    RESET_ORIGIN(2);

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

  public enum LogicCapabilityOperationValue
  {
    LOGIC_CAP_OPERATION_ENABLE(0),
    LOGIC_CAP_OPERATION_DISABLE(1);

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

  public enum LogicCapabilityOperation
  {
    LOGIC_CAP_OPERATION_STOP(0),
    LOGIC_CAP_OPERATION_RESET(1),
    LOGIC_CAP_OPERATION_DOWNLOAD(2),
    LOGIC_CAP_OPERATION_ONLINE_CHANGE(3),
    LOGIC_CAP_OPERATION_SET_BREAKPOINT(4),
    LOGIC_CAP_OPERATION_WRITE_VARIABLE(5),
    LOGIC_CAP_OPERATION_FORCE_VARIABLE(6);

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

  public enum LogicSymbolAccessRights
  {
    ACCESS_RIGHTS_NONE      (0),
    ACCESS_RIGHTS_READ      (1),
    ACCESS_RIGHTS_WRITE     (2),
    ACCESS_RIGHTS_READWRITE (3);

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

  public enum LogicType
  {
    LOGIC_TYPE_BOOL        (0),         
    LOGIC_TYPE_BIT         (1),         
    LOGIC_TYPE_BYTE        (2),         
    LOGIC_TYPE_WORD        (3),         
    LOGIC_TYPE_DWORD       (4),         
    LOGIC_TYPE_LWORD       (5),         
    LOGIC_TYPE_SINT        (6),         
    LOGIC_TYPE_INT         (7),         
    LOGIC_TYPE_DINT        (8),         
    LOGIC_TYPE_LINT        (9),         
    LOGIC_TYPE_USINT       (10),        
    LOGIC_TYPE_UINT        (11),        
    LOGIC_TYPE_UDINT       (12),        
    LOGIC_TYPE_ULINT       (13),        
    LOGIC_TYPE_REAL        (14),        
    LOGIC_TYPE_LREAL       (15),        
    LOGIC_TYPE_STRING      (16),        
    LOGIC_TYPE_WSTRING     (17),        
    LOGIC_TYPE_TIME        (18),        
    LOGIC_TYPE_DATE        (19),        
    LOGIC_TYPE_DATEANDTIME (20),        
    LOGIC_TYPE_TIMEOFDAY   (21),        
    LOGIC_TYPE_POINTER     (22),        
    LOGIC_TYPE_REFERENCE   (23),        
    LOGIC_TYPE_SUBRANGE    (24),        
    LOGIC_TYPE_ENUM        (25),        
    LOGIC_TYPE_ARRAY       (26),        
    LOGIC_TYPE_PARAMS      (27),        
    LOGIC_TYPE_USERDEF     (28),        
    LOGIC_TYPE_NONE        (29),        
    LOGIC_TYPE_ANY         (30),        
    LOGIC_TYPE_ANYBIT      (31),        
    LOGIC_TYPE_ANYDATE     (32),        
    LOGIC_TYPE_ANYINT      (33),        
    LOGIC_TYPE_ANYNUM      (34),        
    LOGIC_TYPE_ANYREAL     (35),        
    LOGIC_TYPE_LAZY        (36),        
    LOGIC_TYPE_LTIME       (37),        
    LOGIC_TYPE_BITCONST    (38),        
    LOGIC_TYPE_MAX_TYPE    (39),        
    LOGIC_TYPE_UNSUPPORTED (255);       

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

  public enum ApplicationMemoryArea
  {
    MEMORY_AREA_INPUT(0),
    MEMORY_AREA_OUTPUT(1),
    MEMORY_AREA_MARKER(2);

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


  /*
   * Classes
   */
  public static class LogicArrayRange
  {
    public int minimum;
    public int maximum;
  }

  public static class LogicSymbolInformation {
    public LogicType                type;
    public LogicType                subType;
    public int                      dataSize;
    public int                      numElements;
    public int                      dimension;
    public LogicArrayRange[]        range = new Logic.LogicArrayRange[LOGIC_MAX_DIMENSION_OF_ARRAY];
    public LogicSymbolAccessRights  accessRights;
  }

  public static class ApplicationTaskInfo
  {
    public String   name;
    public int      priority;
    public boolean  watchdog;
    public int      watchdogTime;
    public int      cycleTime;
    public int      averageCycleTime;
    public int      maxCycleTime;
    public int      minCycleTime;
    public int      cycleCount;
  };

  public static class ApplicationInfo
  {
    public String               name;
    public String               author;
    public String               version;
    public String               description;
    public String               profile;
    public System.DateAndTime   dateTime = new System.DateAndTime();
  };

  public static class ApplicationOpState
  {
    public boolean  none;

    public boolean  loaded;
    public boolean  downloadActive;
    public boolean  onlineChangeActive;
    public boolean  storeBootprojectActive;

    public boolean  forceVariablesActive;
    public boolean  exception;
    public boolean  initializeActive;
    public boolean  storeBootprojectOnlyActive;

    public boolean  exitActive;
    public boolean  deleted;
    public boolean  resetActive;
    public boolean  retainMismatch;

    public boolean  bootprojectValid;
    public boolean  loadBootprojectActive;
    public boolean  flowControlActive;
    public boolean  runInFlash;
  };

  public static class  LogicUserTypeInformation
  {
    public String                  name;
    public LogicSymbolInformation  info = new LogicSymbolInformation();
  };


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

  public Application applications(String name) {
    return new Application(getConnectionHandleObject(), name);
  }

  public native void startApplication();

  public native void runSingleCycleApplication();

  public native void stopApplication();

  public native void resetApplication(ApplicationResetMode mode);

  public native String readVariableBySymbolAsString(String symbol);

  public native void writeVariableBySymbolAsString(String symbol, String data);

  public native String getNameOfApplication(int index);

  public native int getNumberOfApplications();

  public native String loadBootApplication(String file, String path);

  public native LogicCapabilityOperationValue getCapabilityOfOperation(LogicCapabilityOperation operation);

  public native void setCapabilityOfOperation(LogicCapabilityOperation operation, LogicCapabilityOperationValue value);

  public native LogicSymbolInformation getInformationOfSymbol(String symbol);

  public native LogicUserTypeInformation[] getInformationOfUserType(String javaSymbol);

  public native String getStopAxesConfiguration();

}