public override void HandleWriteRequest(DaRequest request)
{
DemoDaAddressSpaceElement daElement = request.AddressSpaceElement as DemoDaAddressSpaceElement;
if (daElement != null)
{
ValueQT value = request.Value;
daElement.ValueChanged(value);
request.Result = EnumResultCode.S_OK;
//generate the event
ArrayList attributeValues = new ArrayList(1);
attributeValues.Add((Byte)value.Data);
char charPressed = (char)((Byte)value.Data);
AeEvent keyEvent = new AeEvent(EnumEventType.TRACKING, "keyboard.key", Console.CATEGORY_ID_KEY_HIT);
keyEvent.Severity = 600;
String message = "key hit : ";
message += charPressed.ToString();
keyEvent.Message = message;
keyEvent.AttributeValueList = attributeValues;
keyEvent.Fire();
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
} // end constructor
public override int HandleReadRequests()
{
int count = Requests.Count;
for (int i = 0; i < count; i++)
{
DaRequest request = (DaRequest)Requests[i];
if (request.PropertyId == 0)
{
// get address space element value
// take the Toolkit cache value
ValueQT cacheValue = null;
request.AddressSpaceElement.GetCacheValue(ref cacheValue);
request.Value = cacheValue;
request.Result = EnumResultCode.S_OK;
}
else
{
// get property value
// get the value from the address space element
MyDaAddressSpaceElement element = request.AddressSpaceElement as MyDaAddressSpaceElement;
if (element != null)
{
element.GetPropertyValue(request);
}
else
{
request.Result = EnumResultCode.E_FAIL;
} // end if ... else
} // end if ... else
} // end for
return(CompleteRequests());
} // end HandleReadRequests
public override void SetValue(ValueQT value)
{
Angle = (short)value.Data;
ValueQT val = new ValueQT(Math.Tan(Angle / 180.0 * 3.14), EnumQuality.GOOD, DateTime.Now);
ValueChanged(val);
}
} // end Trace
public void CheckValuesChanged(ref DateTime r_dt)
{
DateTime dateTimeNow = DateTime.UtcNow;
Random rand = new Random();
bool bSecChanged = r_dt.Second != dateTimeNow.Second;
if (bSecChanged)
{
r_dt = dateTimeNow;
}
ArrayList changedElements = new ArrayList();
ArrayList changedValues = new ArrayList();
ValueQT val = null;
val = new ValueQT(rand.Next(), EnumQuality.GOOD, DateTime.Now);
changedElements.Add(g_rand100ms);
changedValues.Add(val);
if (bSecChanged)
{
val = new ValueQT(rand.Next(), EnumQuality.GOOD, DateTime.Now);
changedElements.Add(g_rand1s);
changedValues.Add(val);
g_angle = ((++g_angle) % 360);
val = new ValueQT(Math.Sin(g_angle / 180.0 * 3.14), EnumQuality.GOOD, DateTime.Now);
changedElements.Add(g_sin);
changedValues.Add(val);
}
Application.Instance.DaAddressSpaceRoot.ValuesChanged(changedElements, changedValues);
} // end CheckValuesChanged
private TestResult TransformNumericIncrement()
{
if (string.IsNullOrEmpty(Property))
{
return(TestResult.ParameterMissing("Property"));
}
object value = GetProperty(Property);
double increment;
if (!double.TryParse(Parameter.ToString(), out increment))
{
return(TestResult.ParameterInvalid("Parameter", "Should be a numeric value representing the increment."));
}
ValueQT valueQT = new ValueQT(value, EnumQuality.GOOD, System.DateTime.MinValue);
TestResult testResult = ValueQTIncrement(valueQT, increment);
if (!testResult.IsGood)
{
return(testResult);
}
//replace property
SetProperty(Property, valueQT.Data);
return(TestResult.Success());
}
} // end HandleReadRequests
public override int HandleWriteRequests()
{
int count = Requests.Count;
MySession pClient = (MySession)Session;
for (int i = 0; i < count; i++)
{
DaRequest request = Requests[i] as DaRequest;
if ((request != null) && (request.ProgressRequestState(EnumRequestState.CREATED, EnumRequestState.INPROGRESS) == true))
{
MyDaAddressSpaceElement element = (MyDaAddressSpaceElement)request.AddressSpaceElement;
if (element != null)
{
if (pClient.Equals(MySession.s_controlingSession))
{
ValueQT valueQT = request.Value;
request.Result = (EnumResultCode)element.ValueChanged(valueQT);
}
else
{
request.Result = EnumResultCode.E_ACCESSDENIED;
} // end if
} // end if
} // end if
} // end for
return(CompleteRequests());
} // end HandleWriteRequests
public override void HandleWriteRequest(DaRequest request)
{
DemoDaAddressSpaceElement daElement = request.AddressSpaceElement as DemoDaAddressSpaceElement;
if (daElement != null)
{
if (m_timeType == TimeType.type_limitSecond)
{
ValueQT writeValue = request.Value;
if ((Byte)writeValue.Data <= 59)
{
daElement.ValueChanged(writeValue);
request.Result = EnumResultCode.S_OK;
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
} // end ctr
//-
#endregion
#region // Public Methods
//------------------------
/// <summary>
/// Adds a namespace element as child to a namespace element
/// </summary>
/// <param name="aChild">Child to be added. Checks if the child provided is a <see cref="DaAddressSpaceElement"/></param>
/// <returns>
/// <line>true - Child successfully. </line>
/// <line>false - Child was not added. If fails, the Child should be released by the user.</line>
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="AddChild"]/doc/*'
/// />
public override bool AddChild(AddressSpaceElement aChild)
{
if (!HasChildren)
{
Application.Instance.Trace(
EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.AddChild", "This element does not allow childred");
return false;
} // end if
DaAddressSpaceElement child = aChild as DaAddressSpaceElement;
if (child == null)
{
Application.Instance.Trace(
EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.AddChild", "Invalid child provided");
return false;
} // end if
// only add the child if no handle assigned
if (child.ObjectHandle == 0)
{
OTSAddressSpaceElementData data = new OTSAddressSpaceElementData();
data.m_name = Marshal.StringToCoTaskMemUni(child.Name);
data.m_itemID = Marshal.StringToCoTaskMemUni(
Name + Application.Instance.AddressSpaceDelimiter + child.Name);
data.m_accessRights = (byte) child.AccessRights;
data.m_ioMode = (byte) child.IoMode;
data.m_datatype = ValueQT.GetVartype(child.Datatype);
data.m_hasChildren = Convert.ToByte(child.HasChildren);
data.m_isBrowsable = Convert.ToByte(child.IsBrowsable);
data.m_elementType = (byte) EnumAddressSpaceElementType.DA;
data.m_userData = child.UserData;
Application.Instance.DaAddressSpaceRoot.AddElementToArray(child);
int result = OTBFunctions.OTSAddAddressSpaceElement(m_objectHandle, data, out child.m_objectHandle);
Marshal.FreeCoTaskMem(data.m_name);
Marshal.FreeCoTaskMem(data.m_itemID);
if (!ResultCode.SUCCEEDED(result))
{
result = Application.Instance.DaAddressSpaceRoot.RemoveElementFromArray(child);
System.Diagnostics.Debug.Assert(ResultCode.SUCCEEDED(result),
"RemoveElementFromArray has failed");
return false;
} // end if ... else
}
else
{
Application.Instance.DaAddressSpaceRoot.AddElementToArray(child);
} // end if ... else
// end if
return base.AddChild(aChild);
} // end AddChild
public static void SetAnalogEngineeringUnits(DemoDaAddressSpaceElement daElement,
Double lowLimit,
Double highLimit,
EnumAccessRights accessRights)
{
ValueQT val = new ValueQT(EnumEUType.ANALOG, EnumQuality.GOOD, DateTime.Now);
DaConstantProperty euType = new DaConstantProperty(
7,
"EUType",
"7",
val);
daElement.AddProperty(euType);
DaProperty euHigh = new DaProperty();
euHigh.Id = 102;
euHigh.Name = "High EU";
euHigh.Description = "High EU Description";
euHigh.ItemId = "102";
euHigh.Datatype = typeof(System.Double);
euHigh.AccessRights = accessRights;
daElement.AddProperty(euHigh);
DaProperty euLow = new DaProperty();
euLow.Id = 103;
euLow.Name = "Low EU";
euLow.Description = "Low EU Description";
euLow.ItemId = "103";
euLow.Datatype = typeof(System.Double);
euLow.AccessRights = accessRights;
daElement.AddProperty(euLow);
}
public override void HandleWriteRequest(DaRequest request)
{
if (request.PropertyId == 0)
{
ValueQT cacheValue = null;
request.AddressSpaceElement.GetCacheValue(ref cacheValue);
request.AddressSpaceElement.ValueChanged(cacheValue);
request.Value = cacheValue;
request.Result = EnumResultCode.S_OK;
}
else if (request.PropertyId == 6020)
{
Function daElement = request.AddressSpaceElement as Function;
if (daElement != null)
{
ValueQT writeValue = request.Value;
daElement.SetValue(writeValue);
request.Result = EnumResultCode.S_OK;
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
} // end constructor
public override int HandleReadRequests()
{
int count = Requests.Count;
for (int i = 0; i < count; i++)
{
DaRequest request = Requests[i] as DaRequest;
if ((request != null) && (request.ProgressRequestState(EnumRequestState.CREATED, EnumRequestState.INPROGRESS) == true))
{
if (request.PropertyId == 0)
{
// get address space element value
// take the toolkit cache value
ValueQT valueQT = null;
request.AddressSpaceElement.GetCacheValue(ref valueQT);
request.Value = valueQT;
request.Result = EnumResultCode.S_OK;
}
else
{
// get property value
// get the value from the address space element
MyDaAddressSpaceElement element = request.AddressSpaceElement as MyDaAddressSpaceElement;
request.Value = new ValueQT(element.ObjectType, EnumQuality.GOOD, DateTime.Now);
request.Result = EnumResultCode.S_OK;
} // end if ... else
} // end if
} // end for
return(CompleteRequests());
} // end HandleReadRequests
} // end RemoveChild
/// <summary>
/// Gets the current value in the element's cache
/// </summary>
/// <param name="aValue">out parameter to be filled in with the <see cref="ValueQT"/> instance of the cache value</param>
/// <returns>
/// returns a result code that should be checked for success. If S_OK, the value provided is valid.
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="GetCacheValue"]/doc/*'
/// />
public virtual int GetCacheValue(ref ValueQT aValue)
{
aValue = null;
int result = (int) EnumResultCode.E_FAIL;
if (m_objectHandle != 0 && IoMode != EnumIoMode.NONE)
{
OTValueData valueData = new OTValueData();
// Allocate space and reset the reserved space
valueData.m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(null, valueData.m_value);
result = OTBFunctions.OTSGetCacheValue(this.m_objectHandle, ref valueData);
if (ResultCode.SUCCEEDED(result))
{
aValue = new ValueQT(ref valueData);
} // end if
OTBFunctions.OTVariantClear(valueData.m_value);
Marshal.FreeCoTaskMem(valueData.m_value);
} // end if
return result;
} // end GetCacheValue
} // end ExecuteCommand
/// <summary>
/// Simulate
/// </summary>
public override void Simulate()
{
try
{
if (m_simulationOn)
{
uint simulationCV = 0;
ValueQT cacheValue = null;
this.GetCacheValue(ref cacheValue);
if (cacheValue != null)
{
simulationCV = Convert.ToUInt32(cacheValue.Data) + 1;
if (simulationCV > 5)
{
simulationCV = 0;
} // end if
this.ValueChanged(simulationCV, 0, "simulation Address", "simulation Text Description");
} // end if
} // end if
}
finally
{
base.Simulate();
} // end try ... finally
} // end Simulate
} // end init
public override void HandleReadRequest(DaRequest request)
{
ValueQT cacheValue = null;
request.AddressSpaceElement.GetCacheValue(ref cacheValue);
request.Value = cacheValue;
request.Result = EnumResultCode.S_OK;
}
} // end HandleStateChanged
public static void HandleValueChanged(DaItem aDaItem, ValueQT aValue)
{
if (aDaItem.Id == "maths.sin")
{
System.Console.WriteLine("Value changed!");
System.Console.WriteLine(String.Format("{0,-19} {1} {2,-50} ", aDaItem.Id, "-", aValue.ToString()));
}
} // end HandleValueChanged
// Return the incremented value for a ValueQT
private int IncrementItemValue(MyDaAddressSpaceElement item)
{
// get actual value
ValueQT itemValue = null;
item.GetCacheValue(ref itemValue);
Type dataType = itemValue.Data.GetType();
object newValue = null;
if (dataType == typeof(bool))
{
newValue = !(bool)itemValue.Data;
}
if (dataType == typeof(Byte))
{
newValue = (Byte)((Byte)itemValue.Data + m_increment);
}
if (dataType == typeof(SByte))
{
newValue = (SByte)((SByte)itemValue.Data + m_increment);
}
if (dataType == typeof(UInt16))
{
newValue = (UInt16)((UInt16)itemValue.Data + m_increment);
}
if (dataType == typeof(Int16))
{
newValue = (Int16)((Int16)itemValue.Data + m_increment);
}
if (dataType == typeof(UInt32))
{
newValue = (UInt32)((UInt32)itemValue.Data + m_increment);
}
if (dataType == typeof(Int32))
{
newValue = (Int32)((Int32)itemValue.Data + m_increment);
}
if (dataType == typeof(UInt64))
{
newValue = (UInt64)((UInt64)itemValue.Data + m_increment);
}
if (dataType == typeof(Int64))
{
newValue = (Int64)((Int64)itemValue.Data + m_increment);
}
if (dataType == typeof(Single))
{
newValue = (Single)((Single)itemValue.Data + m_increment);
}
if (dataType == typeof(Double))
{
newValue = (Double)((Double)itemValue.Data + m_increment);
}
// apply new value
return(item.ValueChanged(new ValueQT(newValue, EnumQuality.GOOD, DateTime.Now)));
}
} // end ExecuteCommand
//-
#endregion
#region // Protected Methods
//---------------------------
/// <summary>
/// HandleItemReadRequest
/// </summary>
protected virtual void HandleItemReadRequest(DaRequest aRequest)
{
ValueQT cacheValue = null;
this.GetCacheValue(ref cacheValue);
aRequest.Value = cacheValue;
aRequest.Result = EnumResultCode.S_OK;
aRequest.Complete();
} // end HandleItemReadRequest
public override TestResult Execute()
{
if (string.IsNullOrEmpty(Session))
{
return(TestResult.ParameterMissing("Session"));
}
DaSession session = GetProperty(Session) as DaSession;
if (session == null)
{
return(TestResult.ParameterInvalid("Session"));
}
if (string.IsNullOrEmpty(NodeSetId))
{
return(TestResult.ParameterMissing("NodeSetId"));
}
string nodeSetId = GetProperty(NodeSetId) as string;
if (nodeSetId == null)
{
return(TestResult.ParameterInvalid("NodeSetId"));
}
try
{
int result = (int)EnumResultCode.S_FALSE;
int[] results;
string[] itemIDs;
ValueQT[] values;
// set stop simulation params
itemIDs = new string[] { nodeSetId + m_deleteVariablesCommand };
values = new ValueQT[] { new ValueQT(true, EnumQuality.GOOD, DateTime.Now) };
// send write request
result = session.Write(itemIDs, null, values, out results, null);
if (ResultCode.SUCCEEDED(result))
{
return(TestResult.Success());
}
else
{
EnumResultCode resCode = (EnumResultCode)Enum.Parse(typeof(EnumResultCode), result.ToString());
return(TestResult.Failed(string.Format("Call returned: {0} ({1})", resCode.ToString(), result)));
}
}
catch (Exception ex)
{
return(new TestResult(ex));
}
}
public override void Simulation()
{
Angle++;
if (Angle >= 360)
{
Angle = 0;
}
ValueQT val = new ValueQT(Math.Tan(Angle / 180.0 * 3.14), EnumQuality.GOOD, DateTime.Now);
ValueChanged(val);
}
public override void HandleWriteRequest(DaRequest request)
{
AlarmSimulation daElement = request.AddressSpaceElement as AlarmSimulation;
if (daElement != null)
{
ValueQT value = request.Value;
daElement.ValueChanged(value);
request.Result = EnumResultCode.S_OK;
// generate the event
ArrayList attributeValues = new ArrayList(1);
attributeValues.Add((Boolean)value.Data);
String actorId = "alarm.simulation";
String message = "Boolean value: ";
Boolean boolVal = (Boolean)value.Data;
if (boolVal)
{
message += "TRUE";
}
else
{
message += "FALSE";
}
switch (daElement.m_alarmType)
{
case AlarmType.simple:
AeEvent fireSimpleEvent = new AeEvent(
EnumEventType.SIMPLE, "alarm simulation.fire simple event", Console.CATEGORY_ID_DA_WRITE_SIMPLE);
fireSimpleEvent.Severity = 700;
fireSimpleEvent.ActorId = actorId;
fireSimpleEvent.Message = message;
fireSimpleEvent.AttributeValueList = attributeValues;
fireSimpleEvent.Fire();
break;
case AlarmType.tracking:
AeEvent fireTrackingEvent = new AeEvent(
EnumEventType.SIMPLE, "alarm simulation.fire tracking event", Console.CATEGORY_ID_DA_WRITE_TRACKING);
fireTrackingEvent.Severity = 750;
fireTrackingEvent.ActorId = actorId;
fireTrackingEvent.Message = message;
fireTrackingEvent.AttributeValueList = attributeValues;
fireTrackingEvent.Fire();
break;
}
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
public void HandleRequests()
{
lock (m_requestsJanitor)
{
foreach (MyRequest request in m_requests)
{
if (request.ProgressRequestState(EnumRequestState.PENDING, EnumRequestState.INPROGRESS))
{
MyDaAddressSpaceElement element = request.AddressSpaceElement as MyDaAddressSpaceElement;
if (element == null)
{
request.Result = EnumResultCode.E_FAIL;
}
else
{
switch (request.TransactionType)
{
case EnumTransactionType.READ:
if (request.PropertyId == 0)
{
ValueQT cacheValue = null;
request.Result = (EnumResultCode)element.GetCacheValue(ref cacheValue);
request.Value = cacheValue;
}
else
{
element.GetPropertyValue(request);
} // end if ... else
break;
case EnumTransactionType.WRITE:
if (request.PropertyId == 0)
{
ValueQT newValue = request.Value;
request.Result = (EnumResultCode)element.ValueChanged(newValue);
}
else
{
request.Result = EnumResultCode.E_BADRIGHTS;
} // end if ... else
break;
default:
break;
} // end switch
} // end if ... else
} // end if ... else
request.Complete();
} // end forech
m_requests.Clear();
} // end lock
} // end HandleRequests
/// <summary>
/// Write DaItem
/// </summary>
/// <param name="itemValue"></param>
/// <param name="dataType"></param>
private void SetWriteItemToDaItem(ValueQT itemValue, Type dataType)
{
//Write DaItem Values
ExecutionOptions executionOptions = new ExecutionOptions();
executionOptions.ExecutionType = EnumExecutionType.ASYNCHRONOUS;
executionOptions.ExecutionContext = 0;
int result;
item.RequestedDatatype = dataType;
this.item.Write(itemValue, out result, executionOptions);
}
void item_ValueChanged(DaItem aDaItem, ValueQT aValue)
{
m_bReceived = true;
//find the right item
for (int i = 0; i < m_items.Length; i++)
{
if (m_items[i] == aDaItem)
{
m_valueChanges[i].Values.Add(new Value(aValue));
}
}
}
//-----------------------------
/// <summary>
/// Default constructor
/// </summary>
/// <param name="anId">Property ID </param>
/// <param name="aName">Property Name</param>
/// <param name="anItemId">Property Id </param>
/// <param name="aValue">Property value</param>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaConstantProperty"]/
/// ctor[@name="DaConstantProperty"]/doc/*'
/// />
public DaConstantProperty(
int anId,
string aName,
string anItemId,
ValueQT aValue)
{
this.Id = anId;
this.Name = aName;
this.ItemId = anItemId;
this.AccessRights = EnumAccessRights.READABLE;
this.m_value = new ValueQT(aValue.Data, aValue.Quality, aValue.TimeStamp);
this.Description = aName;
this.Datatype = aValue.Data.GetType();
} // end default constructor
/// <summary>
/// Set Write AddressSpaceElement
/// </summary>
/// <param name="itemId"></param>
/// <param name="itemValue"></param>
/// <param name="dataType"></param>
private void SetWriteItemToAddSpaceElem(string itemId, ValueQT itemValue, Type dataType)
{
if (session == null)
{
return;
}
//Write DaItem Values
ExecutionOptions executionOptions = new ExecutionOptions();
executionOptions.ExecutionType = EnumExecutionType.ASYNCHRONOUS;
executionOptions.ExecutionContext = 0;
int[] result;
session.Write(new string[] { itemId }, null, new ValueQT[] { itemValue }, out result, executionOptions);
}
} // end QueryProperties
public void HandleAddedToAddressSpace()
{
if (ItemId == "stringBased")
{
ObjectType = 20;
}
else if ((ItemId == "stringBased.N1") || (ItemId == "stringBased.N2"))
{
ObjectType = 21;
}
else if (ItemId == "stringBased.T1")
{
ObjectType = 22;
}
else if ((ItemId == "stringBased.N1.T1") ||
(ItemId == "stringBased.N2.T1") ||
(ItemId == "stringBased.N2.T2"))
{
ObjectType = 23;
}
else if (ItemId == "syntaxBased")
{
ObjectType = 40;
}
else if (ItemId.StartsWith("syntaxBased"))
{
Int32 index;
index = ItemId.LastIndexOf(".T");
if (index > 0)
{
ObjectType = 42; // T
}
else
{
ObjectType = 41; // N
} // end if ... else
} // end if ... else
if (this.IoMode != EnumIoMode.NONE)
{
ValueQT initialValue = new ValueQT(0, EnumQuality.GOOD, DateTime.Now);
ValueChanged(initialValue);
}
OpcServer.AddressSpaceChanged.Set();
} // end HandleAddedToAddressSpace
public override void HandleReadRequest(DaRequest request)
{
DemoDaAddressSpaceElement daElement = request.AddressSpaceElement as DemoDaAddressSpaceElement;
if (daElement != null)
{
ValueQT cacheValue = null;
request.AddressSpaceElement.GetCacheValue(ref cacheValue);
request.Value = cacheValue;
request.Result = EnumResultCode.S_OK;
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
//-----------------------------
/// <summary>
/// DataPointElement
/// </summary>
public DataPointElement(
string aName,
uint aDataTypeId,
string aDescription) :
base()
{
this.Name = aName;
this.HasChildren = false;
this.IoMode = EnumIoMode.POLL;
this.AccessRights = EnumAccessRights.READWRITEABLE;
this.Datatype = typeof(uint);
this.AddProperty(new DataPointTypeProperty(aDataTypeId, "DataPointType", "DataPointType"));
ValueQT value = new ValueQT(aDescription, EnumQuality.GOOD, DateTime.Now);
this.AddProperty(new DaConstantProperty(101, "Description", "101", value));
} // end ctr
public override void HandleWriteRequest(DaRequest request)
{
DemoDaAddressSpaceElement daElement = request.AddressSpaceElement as DemoDaAddressSpaceElement;
if (daElement != null)
{
ValueQT writeValue = request.Value;
daElement.ValueChanged(writeValue);
request.Result = EnumResultCode.S_OK;
// generate the interval period changing
Console.DA_SLEEP_INTERVAL = (UInt32)(writeValue.Data);
}
else
{
request.Result = EnumResultCode.S_FALSE;
}
}
private static TestResult ValueQTSetValue(ValueQT value, double increment)
{
if (value.Data is double)
{
value.SetData((double)((double)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is float)
{
value.SetData((float)((float)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is int)
{
value.SetData((int)((int)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is uint)
{
value.SetData((uint)((uint)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is short)
{
value.SetData((short)((short)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is ushort)
{
value.SetData((ushort)((ushort)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is sbyte)
{
value.SetData((sbyte)((sbyte)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is byte)
{
value.SetData((byte)((byte)increment), value.Quality, value.TimeStamp);
}
else if (value.Data is bool)
{
value.SetData((bool)(increment % 2 == 0), value.Quality, value.TimeStamp);
}
else
{
return(TestResult.ParameterInvalid("Property", "The ValueQT's type is not supported for this operation"));
}
return(TestResult.Success());
}
