You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
794 lines
36 KiB
C#
794 lines
36 KiB
C#
/*
|
|
* Control.cs
|
|
*
|
|
* Copyright 2014-2025 Michael Zillgith
|
|
*
|
|
* This file is part of libIEC61850.
|
|
*
|
|
* libIEC61850 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* libIEC61850 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with libIEC61850. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* See COPYING file for the complete license text.
|
|
*/
|
|
|
|
using IEC61850.Common;
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace IEC61850
|
|
{
|
|
// IEC 61850 common API parts (used by client and server API)
|
|
namespace Common
|
|
{
|
|
|
|
/// <summary>
|
|
/// Control model
|
|
/// </summary>
|
|
public enum ControlModel
|
|
{
|
|
/** status only */
|
|
STATUS_ONLY = 0,
|
|
/** direct with normal security */
|
|
DIRECT_NORMAL = 1,
|
|
/** select before operate (SBO) with normal security */
|
|
SBO_NORMAL = 2,
|
|
/** direct with enhanced security */
|
|
DIRECT_ENHANCED = 3,
|
|
/** select before operate (SBO) with enhanced security */
|
|
SBO_ENHANCED = 4
|
|
}
|
|
|
|
/// <summary>
|
|
/// Originator category
|
|
/// </summary>
|
|
public enum OrCat
|
|
{
|
|
/** Not supported - should not be used */
|
|
NOT_SUPPORTED = 0,
|
|
/** Control operation issued from an operator using a client located at bay level */
|
|
BAY_CONTROL = 1,
|
|
/** Control operation issued from an operator using a client located at station level */
|
|
STATION_CONTROL = 2,
|
|
/** Control operation from a remote operator outside the substation (for example network control center) */
|
|
REMOTE_CONTROL = 3,
|
|
/** Control operation issued from an automatic function at bay level */
|
|
AUTOMATIC_BAY = 4,
|
|
/** Control operation issued from an automatic function at station level */
|
|
AUTOMATIC_STATION = 5,
|
|
/** Control operation issued from a automatic function outside of the substation */
|
|
AUTOMATIC_REMOTE = 6,
|
|
/** Control operation issued from a maintenance/service tool */
|
|
MAINTENANCE = 7,
|
|
/** Status change occurred without control action (for example external trip of a circuit breaker or failure inside the breaker) */
|
|
PROCESS = 8
|
|
}
|
|
}
|
|
|
|
namespace Client
|
|
{
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct LastApplErrorInternal
|
|
{
|
|
public int ctlNum;
|
|
public int error;
|
|
public int addCause;
|
|
}
|
|
|
|
public class LastApplError
|
|
{
|
|
public int ctlNum;
|
|
public int error;
|
|
public ControlAddCause addCause;
|
|
|
|
|
|
internal LastApplError(LastApplErrorInternal lastApplError)
|
|
{
|
|
addCause = (ControlAddCause)lastApplError.addCause;
|
|
error = lastApplError.error;
|
|
ctlNum = lastApplError.ctlNum;
|
|
}
|
|
}
|
|
|
|
public enum ControlActionType
|
|
{
|
|
SELECT = 0,
|
|
OPERATE = 1,
|
|
CANCEL = 2
|
|
}
|
|
|
|
/// <summary>
|
|
/// Control object.
|
|
/// </summary>
|
|
public class ControlObject : IDisposable
|
|
{
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern LastApplErrorInternal ControlObjectClient_getLastApplError(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern IntPtr ControlObjectClient_create(string objectReference, IntPtr connection);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern void ControlObjectClient_destroy(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern int ControlObjectClient_getControlModel(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern int ControlObjectClient_getCtlValType(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern int ControlObjectClient_getLastError(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
[return: MarshalAs(UnmanagedType.I1)]
|
|
private static extern bool ControlObjectClient_operate(IntPtr self, IntPtr ctlVal, UInt64 operTime);
|
|
|
|
/// <summary>
|
|
/// Handler for asynchronous control actions (select, operate, cancel)
|
|
/// </summary>
|
|
public delegate void ControlActionHandler(UInt32 invokeId, Object parameter, IedClientError error, ControlActionType type, bool success);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
private delegate void ControlObjectClient_ControlActionHandler(UInt32 invokeId, IntPtr parameter, int err, int type, [MarshalAs(UnmanagedType.I1)] bool success);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern UInt32 ControlObjectClient_operateAsync(IntPtr self, out int err, IntPtr ctlVal, UInt64 operTime,
|
|
ControlObjectClient_ControlActionHandler handler, IntPtr parameter);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern UInt32 ControlObjectClient_selectAsync(IntPtr self, out int err,
|
|
ControlObjectClient_ControlActionHandler handler, IntPtr parameter);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern UInt32 ControlObjectClient_selectWithValueAsync(IntPtr self, out int err, IntPtr ctlVal,
|
|
ControlObjectClient_ControlActionHandler handler, IntPtr parameter);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern UInt32 ControlObjectClient_cancelAsync(IntPtr self, out int err,
|
|
ControlObjectClient_ControlActionHandler handler, IntPtr parameter);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
[return: MarshalAs(UnmanagedType.I1)]
|
|
private static extern bool ControlObjectClient_select(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
[return: MarshalAs(UnmanagedType.I1)]
|
|
private static extern bool ControlObjectClient_selectWithValue(IntPtr self, IntPtr ctlVal);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
[return: MarshalAs(UnmanagedType.I1)]
|
|
private static extern bool ControlObjectClient_cancel(IntPtr self);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern void ControlObjectClient_setOrigin(IntPtr self, string orIdent, int orCat);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern void ControlObjectClient_setInterlockCheck(IntPtr self, [MarshalAs(UnmanagedType.I1)] bool value);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern void ControlObjectClient_setSynchroCheck(IntPtr self, [MarshalAs(UnmanagedType.I1)] bool value);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern void ControlObjectClient_setTestMode(IntPtr self, [MarshalAs(UnmanagedType.I1)] bool value);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
private delegate void InternalCommandTerminationHandler(IntPtr parameter, IntPtr controlClient);
|
|
|
|
[DllImport("iec61850", CallingConvention = CallingConvention.Cdecl)]
|
|
private static extern void ControlObjectClient_setCommandTerminationHandler(IntPtr self,
|
|
InternalCommandTerminationHandler handler, IntPtr handlerParameter);
|
|
|
|
public delegate void CommandTerminationHandler(Object parameter, ControlObject controlObject);
|
|
|
|
private IedConnection iedConnection;
|
|
private IntPtr self;
|
|
|
|
private CommandTerminationHandler commandTerminationHandler = null;
|
|
private Object commandTerminationHandlerParameter = null;
|
|
|
|
private void MyCommandTerminationHandler(IntPtr paramter, IntPtr controlClient)
|
|
{
|
|
if (commandTerminationHandler != null)
|
|
commandTerminationHandler(commandTerminationHandlerParameter, this);
|
|
}
|
|
|
|
private InternalCommandTerminationHandler intCommandTerminationHandler;
|
|
|
|
internal ControlObject(string objectReference, IntPtr connection, IedConnection iedConnection)
|
|
{
|
|
this.iedConnection = iedConnection;
|
|
|
|
self = ControlObjectClient_create(objectReference, connection);
|
|
|
|
if (self == System.IntPtr.Zero)
|
|
throw new IedConnectionException("Control object not found", 0);
|
|
|
|
intCommandTerminationHandler = new InternalCommandTerminationHandler(MyCommandTerminationHandler);
|
|
|
|
ControlObjectClient_setCommandTerminationHandler(self, intCommandTerminationHandler, self);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the control model.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// The control model.
|
|
/// </returns>
|
|
public ControlModel GetControlModel()
|
|
{
|
|
ControlModel controlModel = (ControlModel)ControlObjectClient_getControlModel(self);
|
|
|
|
return controlModel;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the type of ctlVal.
|
|
/// </summary>
|
|
/// <returns>MmsType required for the ctlVal value.</returns>
|
|
public MmsType GetCtlValType()
|
|
{
|
|
MmsType ctlValType = (MmsType)ControlObjectClient_getCtlValType(self);
|
|
|
|
return ctlValType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the origin parameter used by control commands.
|
|
/// </summary>
|
|
/// <param name='originator'>
|
|
/// Originator. An arbitrary string identifying the controlling client.
|
|
/// </param>
|
|
/// <param name='originatorCategory'>
|
|
/// Originator category.
|
|
/// </param>
|
|
public void SetOrigin(string originator, OrCat originatorCategory)
|
|
{
|
|
ControlObjectClient_setOrigin(self, originator, (int)originatorCategory);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the error code of the last synchronous control action (operate, select, select-with-value, cancel)
|
|
/// </summary>
|
|
/// <value>error code.</value>
|
|
public IedClientError LastError
|
|
{
|
|
get
|
|
{
|
|
return (IedClientError)ControlObjectClient_getLastError(self);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(bool ctlVal)
|
|
{
|
|
return Operate(ctlVal, 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(bool ctlVal, UInt64 operTime)
|
|
{
|
|
MmsValue value = new MmsValue(ctlVal);
|
|
|
|
return Operate(value, operTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(float ctlVal)
|
|
{
|
|
return Operate(ctlVal, 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(float ctlVal, UInt64 operTime)
|
|
{
|
|
MmsValue value = new MmsValue(ctlVal);
|
|
|
|
return Operate(value, operTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(int ctlVal)
|
|
{
|
|
return Operate(ctlVal, 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(int ctlVal, UInt64 operTime)
|
|
{
|
|
MmsValue value = new MmsValue(ctlVal);
|
|
|
|
return Operate(value, operTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(MmsValue ctlVal)
|
|
{
|
|
return Operate(ctlVal, 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <returns>true when the operation has been successful, false otherwise</returns>
|
|
public bool Operate(MmsValue ctlVal, UInt64 operTime)
|
|
{
|
|
return ControlObjectClient_operate(self, ctlVal.valueReference, operTime);
|
|
}
|
|
|
|
private ControlObjectClient_ControlActionHandler internalOperateHandler = null;
|
|
|
|
private void nativeOperateHandler(UInt32 invokeId, IntPtr parameter, int err, int type, bool success)
|
|
{
|
|
GCHandle handle = GCHandle.FromIntPtr(parameter);
|
|
|
|
Tuple<ControlActionHandler, object> callbackInfo = handle.Target as Tuple<ControlActionHandler, object>;
|
|
|
|
ControlActionHandler handler = callbackInfo.Item1;
|
|
object handlerParameter = callbackInfo.Item2;
|
|
|
|
handle.Free();
|
|
|
|
IedClientError clientError = (IedClientError)err;
|
|
|
|
handler(invokeId, handlerParameter, clientError, (ControlActionType)type, success);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(bool ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return OperateAsync(ctlVal, 0, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(bool ctlVal, UInt64 operTime, ControlActionHandler handler, object parameter)
|
|
{
|
|
MmsValue value = new MmsValue(ctlVal);
|
|
|
|
return OperateAsync(value, operTime, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(float ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return OperateAsync(ctlVal, 0, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(float ctlVal, UInt64 operTime, ControlActionHandler handler, object parameter)
|
|
{
|
|
MmsValue value = new MmsValue(ctlVal);
|
|
|
|
return OperateAsync(value, operTime, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(int ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return OperateAsync(ctlVal, 0, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(int ctlVal, UInt64 operTime, ControlActionHandler handler, object parameter)
|
|
{
|
|
return OperateAsync(ctlVal, operTime, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value.
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(MmsValue ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return OperateAsync(ctlVal, 0, handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Operate the control with the specified control value (time activated control).
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the new value of the control</param>
|
|
/// <param name='operTime'>the time when the operation will be executed</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 OperateAsync(MmsValue ctlVal, UInt64 operTime, ControlActionHandler handler, object parameter)
|
|
{
|
|
int error;
|
|
|
|
Tuple<ControlActionHandler, object> callbackInfo = Tuple.Create(handler, parameter);
|
|
|
|
GCHandle handle = GCHandle.Alloc(callbackInfo);
|
|
|
|
if (internalOperateHandler == null)
|
|
internalOperateHandler = new ControlObjectClient_ControlActionHandler(nativeOperateHandler);
|
|
|
|
UInt32 invokeId = ControlObjectClient_operateAsync(self, out error, ctlVal.valueReference, operTime, internalOperateHandler, GCHandle.ToIntPtr(handle));
|
|
|
|
if (error != 0)
|
|
{
|
|
handle.Free();
|
|
throw new IedConnectionException("Operate failed", error);
|
|
}
|
|
|
|
return invokeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Select the control object.
|
|
/// </summary>
|
|
/// <returns>true when the selection has been successful, false otherwise</returns>
|
|
public bool Select()
|
|
{
|
|
return ControlObjectClient_select(self);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Select the control object.
|
|
/// </summary>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 SelectAsync(ControlActionHandler handler, object parameter)
|
|
{
|
|
int error;
|
|
|
|
Tuple<ControlActionHandler, object> callbackInfo = Tuple.Create(handler, parameter);
|
|
|
|
GCHandle handle = GCHandle.Alloc(callbackInfo);
|
|
|
|
if (internalOperateHandler == null)
|
|
internalOperateHandler = new ControlObjectClient_ControlActionHandler(nativeOperateHandler);
|
|
|
|
UInt32 invokeId = ControlObjectClient_selectAsync(self, out error, internalOperateHandler, GCHandle.ToIntPtr(handle));
|
|
|
|
if (error != 0)
|
|
{
|
|
handle.Free();
|
|
throw new IedConnectionException("Select failed", error);
|
|
}
|
|
|
|
return invokeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for generic MmsValue instances
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the value to be checked.</param>
|
|
/// <returns>true when the selection has been successful, false otherwise</returns>
|
|
public bool SelectWithValue(MmsValue ctlVal)
|
|
{
|
|
return ControlObjectClient_selectWithValue(self, ctlVal.valueReference);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for boolean controls
|
|
/// </summary>
|
|
/// <param name='ctlVal'>
|
|
/// the value to be checked.
|
|
/// </param>
|
|
/// <returns>true when the selection has been successful, false otherwise</returns>
|
|
public bool SelectWithValue(bool ctlVal)
|
|
{
|
|
return SelectWithValue(new MmsValue(ctlVal));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for integer controls
|
|
/// </summary>
|
|
/// <param name='ctlVal'>
|
|
/// the value to be checked.
|
|
/// </param>
|
|
/// <returns>true when the selection has been successful, false otherwise</returns>
|
|
public bool SelectWithValue(int ctlVal)
|
|
{
|
|
return SelectWithValue(new MmsValue(ctlVal));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for float controls
|
|
/// </summary>
|
|
/// <param name='ctlVal'>
|
|
/// the value to be checked.
|
|
/// </param>
|
|
/// <returns>true when the selection has been successful, false otherwise</returns>
|
|
public bool SelectWithValue(float ctlVal)
|
|
{
|
|
return SelectWithValue(new MmsValue(ctlVal));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for boolean controls - asynchronous version
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the value to be checked.</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 SelectWithValueAsync(bool ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return SelectWithValueAsync(new MmsValue(ctlVal), handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for integer controls - asynchronous version
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the value to be checked.</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 SelectWithValueAsync(int ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return SelectWithValueAsync(new MmsValue(ctlVal), handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for float controls - asynchronous version
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the value to be checked.</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 SelectWithValueAsync(float ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
return SelectWithValueAsync(new MmsValue(ctlVal), handler, parameter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a select with value command for generic MmsValue instances - asynchronous version
|
|
/// </summary>
|
|
/// <param name='ctlVal'>the value to be checked.</param>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public UInt32 SelectWithValueAsync(MmsValue ctlVal, ControlActionHandler handler, object parameter)
|
|
{
|
|
int error;
|
|
|
|
Tuple<ControlActionHandler, object> callbackInfo = Tuple.Create(handler, parameter);
|
|
|
|
GCHandle handle = GCHandle.Alloc(callbackInfo);
|
|
|
|
if (internalOperateHandler == null)
|
|
internalOperateHandler = new ControlObjectClient_ControlActionHandler(nativeOperateHandler);
|
|
|
|
UInt32 invokeId = ControlObjectClient_selectWithValueAsync(self, out error, ctlVal.valueReference, internalOperateHandler, GCHandle.ToIntPtr(handle));
|
|
|
|
if (error != 0)
|
|
{
|
|
handle.Free();
|
|
throw new IedConnectionException("Select with value failed", error);
|
|
}
|
|
|
|
return invokeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cancel a selection or time activated operation
|
|
/// </summary>
|
|
/// <returns>true when the cancelation has been successful, false otherwise</returns>
|
|
/// <param name="handler">Callback function to handle the received response or service timeout</param>
|
|
/// <param name="parameter">User provided callback parameter. Will be passed to the callback function</param>
|
|
/// <returns>the invoke ID of the sent request</returns>
|
|
/// <exception cref="IedConnectionException">This exception is thrown if there is a connection or service error</exception>
|
|
public bool Cancel()
|
|
{
|
|
return ControlObjectClient_cancel(self);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cancel a selection or time activated operation
|
|
/// </summary>
|
|
public UInt32 CancelAsync(ControlActionHandler handler, object parameter)
|
|
{
|
|
int error;
|
|
|
|
Tuple<ControlActionHandler, object> callbackInfo = Tuple.Create(handler, parameter);
|
|
|
|
GCHandle handle = GCHandle.Alloc(callbackInfo);
|
|
|
|
if (internalOperateHandler == null)
|
|
internalOperateHandler = new ControlObjectClient_ControlActionHandler(nativeOperateHandler);
|
|
|
|
UInt32 invokeId = ControlObjectClient_cancelAsync(self, out error, internalOperateHandler, GCHandle.ToIntPtr(handle));
|
|
|
|
if (error != 0)
|
|
{
|
|
handle.Free();
|
|
throw new IedConnectionException("Cancel failed", error);
|
|
}
|
|
|
|
return invokeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enables the synchro check for operate commands
|
|
/// </summary>
|
|
[Obsolete("use SetSynchroCheck instead")]
|
|
public void EnableSynchroCheck()
|
|
{
|
|
ControlObjectClient_setSynchroCheck(self, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enables the interlock check for operate and select commands
|
|
/// </summary>
|
|
[Obsolete("use SetInterlockCheck instead")]
|
|
public void EnableInterlockCheck()
|
|
{
|
|
ControlObjectClient_setInterlockCheck(self, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the value of the interlock check flag for operate and select commands
|
|
/// </summary>
|
|
public void SetInterlockCheck(bool value)
|
|
{
|
|
ControlObjectClient_setInterlockCheck(self, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the value of the synchro check flag for operate command
|
|
/// </summary>
|
|
public void SetSynchroCheck(bool value)
|
|
{
|
|
ControlObjectClient_setSynchroCheck(self, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the value of the test flag for the operate command
|
|
/// </summary>
|
|
public void SetTestMode(bool value)
|
|
{
|
|
ControlObjectClient_setTestMode(self, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the last received LastApplError (Additional Cause Diagnostics) value.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// The last appl error.
|
|
/// </returns>
|
|
public LastApplError GetLastApplError()
|
|
{
|
|
LastApplErrorInternal lastApplError = ControlObjectClient_getLastApplError(self);
|
|
|
|
return new LastApplError(lastApplError);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the command termination handler.
|
|
/// </summary>
|
|
/// <param name='handler'>
|
|
/// the handler (delegate) that is invoked when a CommandTerminationMessage is received.
|
|
/// </param>
|
|
/// <param name='parameter'>
|
|
/// Parameter.
|
|
/// </param>
|
|
public void SetCommandTerminationHandler(CommandTerminationHandler handler, Object parameter)
|
|
{
|
|
commandTerminationHandler = handler;
|
|
commandTerminationHandlerParameter = parameter;
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (self != System.IntPtr.Zero)
|
|
{
|
|
ControlObjectClient_destroy(self);
|
|
self = System.IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
|
|
~ControlObject()
|
|
{
|
|
Dispose(false);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|