System.java

Go to the documentation of this file.

// -----------------------------------------------------------------------
// MLPI - <System.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 System extends MlpiComponent {
  /*
   * Constants
   */
  final public String VERSION_FIRMWARE          = "VERSION_FIRMWARE";
  final public String VERSION_HARDWARE          = "VERSION_HARDWARE";
  final public String VERSION_LOGIC             = "VERSION_LOGIC";
  final public String VERSION_BSP               = "VERSION_BSP";
  final public String VERSION_MLPI_SERVER_CORE  = "VERSION_MLPI_SERVER_CORE";

  /*
   * Enums
   */
  public enum Language
  {
    LANGUAGE_GERMAN       (0),
    LANGUAGE_ENGLISH      (1),
    LANGUAGE_USER_DEFINED (99);

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

  public enum SystemMode
  {
    SYSTEMMODE_P0         (0x00),
    SYSTEMMODE_P1         (0x01),
    SYSTEMMODE_P2         (0x02),
    SYSTEMMODE_P3         (0x03),
    SYSTEMMODE_BB         (0x04),
    SYSTEMMODE_SWITCHING  (0xFF);

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

  public enum DiagnosisState
  {
    DIAGNOSIS_PASSIVE  (0x00),
    DIAGNOSIS_ACTIVE   (0x01),
    DIAGNOSIS_RESET    (0x02),
    DIAGNOSIS_UNKNOWN  (0x03);

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

  public enum DiagnosisDespatcher
  {
    DESPATCHER_CONTROL   (0x00),
    DESPATCHER_DRIVE     (0x01),
    DESPATCHER_LOGIC     (0x02),
    DESPATCHER_AXIS      (0x03),
    DESPATCHER_KINEMATIC (0x04),
    DESPATCHER_PCI       (0x05);

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

  public enum MlpiLedPattern
  {
    MLPI_LED_PATTERN_GREEN             (  0),
    MLPI_LED_PATTERN_GREEN_250         (  1),
    MLPI_LED_PATTERN_GREEN_500         (  2),
    MLPI_LED_PATTERN_GREEN_1000        (  3),
    MLPI_LED_PATTERN_GREEN_ORANGE_250  (  4),
    MLPI_LED_PATTERN_GREEN_ORANGE_500  (  5),
    MLPI_LED_PATTERN_GREEN_ORANGE_1000 (  6),
    MLPI_LED_PATTERN_GREEN_RED_250     (  7),
    MLPI_LED_PATTERN_GREEN_RED_500     (  8),
    MLPI_LED_PATTERN_GREEN_RED_1000    (  9),
    MLPI_LED_PATTERN_INVALID           ( -1);

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

  public enum SpecialPath
  {
    PATH_SYSTEM                           (0x00),
    PATH_OEM                              (0x01),
    PATH_USER                             (0x02),
    PATH_PROJECTDATAPROTECTED             (0x03),
    PATH_PROJECTDATA                      (0x04),
    PATH_PROJECTDATA_BUNDLES              (0x05),
    PATH_PROJECTDATA_PLC                  (0x06),
    PATH_PROJECTDATA_TMP                  (0x07),
    PATH_PROJECTDATA_JVM                  (0x08),
    PATH_PROJECTDATA_JVM_BUNDLES          (0x09),
    PATH_PROJECTDATA_JVM_LIC              (0x0A),
    PATH_PROJECTDATA_JVM_USER             (0x0B),
    PATH_PROJECTDATAPROTECTED_BUNDLES     (0x0C),
    PATH_PROJECTDATAPROTECTED_JVM         (0x0D),
    PATH_PROJECTDATAPROTECTED_JVM_BUNDLES (0x0E),
    PATH_PROJECTDATAPROTECTED_JVM_LIC     (0x0F),
    PATH_PROJECTDATAPROTECTED_JVM_USER    (0x10);

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

  public enum DiagnosisCategory
  {
    DIAGNOSIS_ERROR_FATAL             (0xF8),
    DIAGNOSIS_ERROR_NONFATAL_CONTROL  (0xF5),
    DIAGNOSIS_ERROR_NONFATAL          (0xF0),
    DIAGNOSIS_WARNING                 (0xE0),
    DIAGNOSIS_MESSAGE                 (0xA0);

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

  public enum MlpiSystemLimit
  {
    MAX_APPLICATIONS    ( 0),
    MAX_CONTROLS        ( 1),
    MAX_AXIS            ( 2),
    MAX_PLS             ( 3),
    MAX_KINEMATICS      ( 4),
    MAX_TOUCHPROBES     ( 5),
    MAX_OSCI_CHANNELS   ( 6),
    INVALID             (-1);

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

  /*
   * Structs
   */
  public static class DateAndTime
  {
    public short  year;         
    public short  month;        
    public short  day;          
    public short  hour;         
    public short  minute;       
    public short  second;       
    public short  milliSecond;  
    public short  microSecond;  
    public short  dayOfWeek;    
    public short  dayOfYear;    
    
    @Override
    public String toString() 
    {
      return String.format("%04d-%02d-%02d %02d:%02d:%02d.%03d", year,month,day,hour,minute,second,milliSecond);
    }
  };

  public static class Diagnosis
  {
    public long                 number;                        
    public DiagnosisState       state;                         
    public DateAndTime          dateTime = new DateAndTime();  
    public int                  logicalAddress;                
    public int                  physicalAddress;               
    public DiagnosisDespatcher  despatcher;                    
    public long                 index;                         
    public String               text;                          
    
    @Override
    public String toString() 
    {
      String numberAsString = Long.toHexString(number);
      return numberAsString.substring(0,4) + "." + numberAsString.substring(4,numberAsString.length()) + "\t" + dateTime.toString() + "\t" + text;
    }
  }

  public static class MemoryInfo
  {
    public long totalVolatileBytes;     
    public long totalNonvolatileBytes;  
    public long freeVolatileBytes;      
    public long freeNonvolatileBytes;   
    
    @Override
    public String toString() 
    {
      return  "total volatile memory:\t" + convertBytes(totalVolatileBytes) + "\t free volatile memory:\t" + convertBytes(freeVolatileBytes) +
          "\ttotal non-volatile memory:\t" + convertBytes(totalNonvolatileBytes) + "\t free non-volatile memory:\t" + convertBytes(freeNonvolatileBytes);
    }
    
    private String convertBytes(long bytes) 
    {
      if(bytes < 1024) return bytes + " Bytes";
      int exp = (int) (Math.log(bytes) / Math.log(1024));
      String unit = "KMGTPE".charAt(exp-1) + "i";
        return String.format("%.1f %sB", bytes / Math.pow(1024, exp), unit);
    }
  }

  public static class SpecialPathInfo
  {
    public long totalDiskspace;  
    public long freeDiskspace;   
    
    @Override
    public String toString() 
    { 
      return "free diskspace:\t" + convertBytes(freeDiskspace) + "\ttotal diskspace\t" + convertBytes(totalDiskspace);
    }
    
    private String convertBytes(long bytes) 
    {
      if(bytes < 1024) return bytes + " Bytes";
      int exp = (int) (Math.log(bytes) / Math.log(1024));
      String unit = "KMGTPE".charAt(exp-1) + "i";
        return String.format("%.1f %sB", bytes / Math.pow(1024, exp), unit);
    }
  };



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

  public native String getName();

  public native void setName(String name);
  
  public native long getTargetId();


  public native float getTemperature();

  public native float getTemperatureMax();

  public native void resetTemperature();

  public native String getIpAddress();

  public native void setIpAddress(String ipAddress);

  public native String getSubnetMask();

  public native void setSubnetMask(String subnetMask);

  public native String getGateway();

  public native void setGateway(String gateway);

  public native SystemMode getCurrentMode();

  public native void setTargetMode(SystemMode mode);

  public native float getCpuLoad();

  public native float getCpuLoadMax();

  public native void resetCpuLoad();

  public native Diagnosis getDisplayedDiagnosis();

  public native long getNewestDiagnosisIndex();

  public native long getOldestDiagnosisIndex();

  public native Diagnosis[] getDiagnosisLog(long startIndex, long numToRead);

  public native String convertDiagnosisNumberToText(int diagnosisNumber);

  public native long getOperationHours();

  public native void reboot();

  public native void cleanup();

  public native Language getLanguage();

  public native void setLanguage(Language language);

  public native SpecialPathInfo getSpecialPathInfo(SpecialPath pathIdentifier);

  public native MemoryInfo getMemoryInfo();

  public native DateAndTime getDateAndTimeUtc();

  public native void setDateAndTimeUtc(DateAndTime dateTime);

  public native void setDateAndTimeUtcByNtp(long timeout, String server, int port);

  public native String getSpecialPath(SpecialPath pathIdentifier);

  public native String[] getRootPaths();

  public native String getLicenseInformation();

  public native String getVersionInfo(String component);

  public native String getSerialNumber();

  public native String getMacAddress();

  public native void clearError();

  public native String getHardwareDetails();

  public native void setDiagnosis(DiagnosisCategory category, int number, String diagnosisText);

  public native void setBootLed(MlpiLedPattern pattern, int count);

  public native void clearBootLed();

  public native long getLimit(MlpiSystemLimit limit);
}