ILogic.idl

Go to the documentation of this file.

// -----------------------------------------------------------------------
// MLPI - <ILogic.idl>
// -----------------------------------------------------------------------
// 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.
// -----------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------



[
  object,
  uuid(7547778A-E3E1-4BFF-A5D6-9279943D9318),
  dual,
  nonextensible,
  helpstring("ILogic Interface"),
  pointer_default(unique)
]
interface ILogic : IDispatch{

  const LONG LOGIC_MAX_DIMENSION_OF_ARRAY = 3; 

  typedef [v1_enum] enum ApplicationState
  {
    STATE_NONE = 0,               
    STATE_RUN  = 1,               
    STATE_STOP = 2,               
    STATE_BP   = 3                
  }ApplicationState;

  typedef [v1_enum] enum ApplicationResetMode
  {
    RESET_WARM   = 0,             
    RESET_COLD   = 1,             
    RESET_ORIGIN = 2              
  }ApplicationResetMode;

  typedef [v1_enum] enum LogicSymbolAccessRights
  {
    ACCESS_RIGHTS_NONE      = 0,  
    ACCESS_RIGHTS_READ      = 1,  
    ACCESS_RIGHTS_WRITE     = 2,  
    ACCESS_RIGHTS_READWRITE = 3   
  }LogicSymbolAccessRights;

  typedef [v1_enum] 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        
  }LogicType;

#if defined(WIN32) || defined(WIN64)
  [
    uuid(2D4AA589-F60E-453a-8C63-99F223FB6169)
  ]
  struct LogicArrayRange
  {
    LONG minimum;
    LONG maximum;
  };

  [
    uuid(6B8D143B-C91E-417f-A73E-D99FAEDFE9C0)
  ]
  struct LogicSymbolInformation
  {
    LogicType                 type;
    LogicType                 subType;
    LONG                      dataSize;
    LONG                      numElements;
    LONG                      dimension;
    struct LogicArrayRange    range[LOGIC_MAX_DIMENSION_OF_ARRAY];
    LogicSymbolAccessRights   accessRights;
  };

  [
    uuid(945D635F-546F-4cfe-9873-3126C420F03F)
  ]
  struct LogicUserTypeInformation
  {
    BSTR                           name;
    struct LogicSymbolInformation  info;
  };
#endif

  typedef [v1_enum] enum LogicCapabilityOperationValue
  {
    LOGIC_CAP_OPERATION_ENABLE  = 0,        
    LOGIC_CAP_OPERATION_DISABLE = 1         
  }LogicCapabilityOperationValue;

  typedef [v1_enum] 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    
  }LogicCapabilityOperation;

  typedef [v1_enum] enum ApplicationMemoryArea
  {
    MEMORY_AREA_INPUT  = 0,              
    MEMORY_AREA_OUTPUT = 1,              
    MEMORY_AREA_MARKER = 2               
  }ApplicationMemoryArea;

#if defined(WIN32) || defined(WIN64)
  [
    uuid(1D9C801D-8E7B-4591-9B81-51C00E5C0383)
  ]
  struct ApplicationTaskInfo
  {
    BSTR          name;
    LONG          priority;
    VARIANT_BOOL  watchdogEnabled;
    LONG          watchdogTime;
    LONG          cycleTime;
    LONG          averageCycleTime;
    LONG          maxCycleTime;
    LONG          minCycleTime;
    LONG          cycleCount;
  };

  struct ApplicationInfo
  {
    BSTR                name;
    BSTR                author;
    BSTR                version;
    BSTR                description;
    BSTR                profile;
    struct DateAndTime  dateTime;
  };
#endif

  struct ApplicationOpState
  {
    VARIANT_BOOL  none;

    VARIANT_BOOL  loaded;
    VARIANT_BOOL  downloadActive;
    VARIANT_BOOL  onlineChangeActive;
    VARIANT_BOOL  storeBootprojectActive;

    VARIANT_BOOL  forceVariablesActive;
    VARIANT_BOOL  exception;
    VARIANT_BOOL  initializeActive;
    VARIANT_BOOL  storeBootprojectOnlyActive;

    VARIANT_BOOL  exitActive;
    VARIANT_BOOL  deleted;
    VARIANT_BOOL  resetActive;
    VARIANT_BOOL  retainMismatch;

    VARIANT_BOOL  bootprojectValid;
    VARIANT_BOOL  loadBootprojectActive;
    VARIANT_BOOL  flowControlActive;
    VARIANT_BOOL  runInFlash;
  };


  [propget, id(1), helpstring("Property Applications")] HRESULT Applications([out, retval] IApplications** applications);

  [id(2), helpstring("Method WriteVariableBySymbol")] HRESULT WriteVariableBySymbol([in] BSTR symbol, [in] VARIANT data);

  [id(3), helpstring("Method ReadVariableBySymbol")] HRESULT ReadVariableBySymbol([in] BSTR symbol, [out, retval] VARIANT* data);

#if defined(WIN32) || defined(WIN64)
  [id(4), helpstring("Method GetInformationOfSymbol")] HRESULT GetInformationOfSymbol([in] BSTR symbol, [out, retval] struct LogicSymbolInformation* info);

  [id(5), helpstring("Method GetInformationOfUserType")] HRESULT GetInformationOfUserType([in] BSTR symbol, [out, retval] SAFEARRAY (struct LogicUserTypeInformation) *logicInfo);
#endif

  [id(6), helpstring("Method ReadVariableBySymbolAsString")] HRESULT ReadVariableBySymbolAsString([in] BSTR symbol, [out, retval] BSTR* data);

  [id(7), helpstring("Method WriteVariableBySymbolAsString")] HRESULT WriteVariableBySymbolAsString([in] BSTR symbol, [in] BSTR data);

  [id(8), helpstring("Method LoadBootApplication")] HRESULT LoadBootApplication([in] BSTR file, [in] BSTR path, [out, retval] BSTR *applicationName);

  [id(9), helpstring("Method GetNumberOfApplications")] HRESULT GetNumberOfApplications([out, retval] LONG *number);

  [id(10), helpstring("Method GetNameOfApplication")] HRESULT GetNameOfApplication([in] LONG index, [out, retval] BSTR *application);

  [id(11), helpstring("Method StartApplication")] HRESULT StartApplication(void);

  [id(12), helpstring("Method StopApplication")] HRESULT StopApplication(void);

  [id(13), helpstring("Method ResetApplication")] HRESULT ResetApplication([in] ApplicationResetMode mode);

  [id(14), helpstring("Method SetCapabilityOfOperation")] HRESULT SetCapabilityOfOperation([in] LogicCapabilityOperation operation, [in] LogicCapabilityOperationValue value);

  [id(15), helpstring("Method SetCapabilityOfOperation")] HRESULT GetCapabilityOfOperation([in] LogicCapabilityOperation operation, [out, retval] LogicCapabilityOperationValue *value);

  //[id(16), helpstring("Method RunSingleCycleApplication")] HRESULT RunSingleCycleApplication(void);

};


// -----------------------------------------------------------------------
// HISTORY
// -----------------------------------------------------------------------
// 01-Jan-2012
//   - first release
//