public void setValue(object aNewValue) { bool lValueChanged = false; Monitor.Enter(mValueLock); //========================================= try { if (mNeedWrite) { return; } if (ValuesCompare.isNotEqual(mValue, aNewValue)) { mValue = aNewValue; lValueChanged = true; } } finally { //========================================= Monitor.Exit(mValueLock); } if (lValueChanged) { raiseValueChanged(); } }
public void setValue(object aValue) { if (ValuesCompare.isNotEqual(mValue, aValue)) { bool lTypeChanged = true; if (mValue != null) { lTypeChanged = (mValue.GetType() != aValue.GetType()); } else { lTypeChanged = true; } mValue = aValue; if (Access.HasFlag(EAccess.READ)) { raiseValueChanged(); } if (lTypeChanged) { raisePropertiesChanged(); } } }
public void onItemValueChange(int aItemHandle, object aItemValue) { if (aItemHandle == mOnItemHandle) { bool lValue; try { lValue = Convert.ToBoolean(aItemValue); } catch (Exception lExc) { throw new ArgumentException("Value conversion error for object to switch on. ", lExc); } if (mOn != lValue) { mOn = lValue; raiseValuesChanged(); push(); correctInterval(); } return; } if (aItemHandle == mInValueItemHandle) { if (ValuesCompare.isNotEqual(aItemValue, mInValue)) { mInValue = aItemValue; raiseValuesChanged(); push(); correctInterval(); } return; } if (aItemHandle == mOutValueItemHandle) { if (ValuesCompare.isNotEqual(aItemValue, mOutValue)) { mValueChanged = true; } return; } }
private void NotificationReceived(IList <MonitoredItemNotification> aDataChanges) { MonitoredItem lMItem; DataItem lItem; int lCount = aDataChanges.Count; for (int i = 0; i < lCount; i++) { mItemListLock.EnterReadLock(); //======================================== try { lMItem = mSubscription.FindItemByClientHandle(aDataChanges[i].ClientHandle); if (lMItem != null) { lItem = lMItem.Handle as DataItem; if (aDataChanges[i].Value.StatusCode != lItem.StatusCode) { lItem.StatusCode = aDataChanges[i].Value.StatusCode; lItem.raisePropertiesChanged(); } if (aDataChanges[i].Value.Value != null) { if (ValuesCompare.isNotEqual(lItem.mValue, aDataChanges[i].Value.Value)) { lItem.mValue = aDataChanges[i].Value.Value; if (lItem.Access.HasFlag(EAccess.READ)) { lItem.raiseValueChanged(); } } } } } catch (Exception lExc) { raiseConnectionError("Error updating value. " + lExc.ToString()); } finally { //======================================== mItemListLock.ExitReadLock(); } } }
public void setValue(SDataValue aValue) { if (mNeedWrite) { return; } mPDataType = aValue.Type; object lNewValue; switch (aValue.Type) { case EPrimitiveDataType.Bool: lNewValue = aValue.Bool; break; case EPrimitiveDataType.Int8: lNewValue = aValue.Int8; break; case EPrimitiveDataType.Int16: lNewValue = aValue.Int16; break; case EPrimitiveDataType.Int32: lNewValue = aValue.Int32; break; case EPrimitiveDataType.Int64: lNewValue = aValue.Int64; break; case EPrimitiveDataType.UInt8: lNewValue = aValue.UInt8; break; case EPrimitiveDataType.UInt16: lNewValue = aValue.UInt16; break; case EPrimitiveDataType.UInt32: lNewValue = aValue.UInt32; break; case EPrimitiveDataType.UInt64: lNewValue = aValue.UInt64; break; case EPrimitiveDataType.Float: lNewValue = aValue.Float; break; case EPrimitiveDataType.Double: lNewValue = aValue.Double; break; case EPrimitiveDataType.Char: lNewValue = aValue.Char; break; case EPrimitiveDataType.WChar: lNewValue = aValue.WChar; break; default: throw new InvalidOperationException("Type is not supported. "); } bool lValueChanged = false; Monitor.Enter(mValueLock); //========================================= try { if (mNeedWrite) { return; } if (ValuesCompare.isNotEqual(mValue, lNewValue)) { mValue = lNewValue; lValueChanged = true; } } finally { //========================================= Monitor.Exit(mValueLock); } if (lValueChanged) { raiseValueChanged(); } }
public void onItemValueChange(int aItemHandle, object aItemValue) { if (mArrayValue.Length == 0) { return; } if (mDataFlow.HasFlag(EDataFlow.FROM)) { if (aItemHandle == mArrayValueItemHandle) { Array lArray = aItemValue as Array; if (lArray != null) { for (int i = 0; i < lArray.Length; i++) { if (i == mArrayValue.Length) { return; } if (ValuesCompare.isNotEqual(lArray.GetValue(i), mArrayValue[i])) { mArrayValue[i] = lArray.GetValue(i); if (mElementItemHandles[i] != -1) { mElementValueChanged[i] = true; mValueChanged = true; } } } } else { if (ValuesCompare.isNotEqual(aItemValue, mArrayValue[0])) { mArrayValue[0] = aItemValue; if (mElementItemHandles[0] != -1) { mElementValueChanged[0] = true; mValueChanged = true; } } } return; } if (mDataFlow.HasFlag(EDataFlow.TO) == false) { for (int i = 0; i < mElementItemHandles.Length; i++) { if (aItemHandle == mElementItemHandles[i]) { mElementValueChanged[i] = true; mValueChanged = true; return; } } } } if (mDataFlow.HasFlag(EDataFlow.TO)) { if (mDataFlow.HasFlag(EDataFlow.FROM) == false && aItemHandle == mArrayValueItemHandle) { mArrayValueChanged = true; mValueChanged = true; return; } for (int i = 0; i < mElementItemHandles.Length; i++) { if (aItemHandle == mElementItemHandles[i]) { if (ValuesCompare.isNotEqual(aItemValue, mArrayValue[i])) { mArrayValue[i] = aItemValue; mArrayValueChanged = true; mValueChanged = true; } return; } } } }
public void onItemValueChange(int aItemHandle, object aItemValue) { if (aItemHandle == mXValueItemHandle) { int lValue; try { lValue = Convert.ToInt32(aItemValue); } catch (Exception lExc) { throw new ArgumentException("X value conversion error. ", lExc); } if (mXValue != lValue) { mXValue = lValue; raiseValuesChanged(); } return; } if (aItemHandle == mYValueItemHandle) { int lValue; try { lValue = Convert.ToInt32(aItemValue); } catch (Exception lExc) { throw new ArgumentException("Y value conversion error. ", lExc); } if (mYValue != lValue) { mYValue = lValue; raiseValuesChanged(); } return; } if (aItemHandle == mVisibleItemHandle) { bool lValue; try { lValue = Convert.ToBoolean(aItemValue); } catch (Exception lExc) { throw new ArgumentException("Value conversion error for visibility state. ", lExc); } if (mVisible != lValue) { mVisible = lValue; raiseValuesChanged(); } return; } if (aItemHandle == mWidthItemHandle) { int lValue; try { lValue = Convert.ToInt32(aItemValue); } catch (Exception lExc) { throw new ArgumentException("Width value conversion error. ", lExc); } if (lValue > MaxWidth) { lValue = MaxWidth; } if (mWidth != lValue) { mWidth = lValue; updatePanelBitmap(); raisePropertiesChanged(); } return; } if (aItemHandle == mHeightItemHandle) { int lValue; try { lValue = Convert.ToInt32(aItemValue); } catch (Exception lExc) { throw new ArgumentException("Height value conversion error. ", lExc); } if (lValue > MaxHeight) { lValue = MaxHeight; } if (mHeight != lValue) { mHeight = lValue; updatePanelBitmap(); raisePropertiesChanged(); } return; } if (aItemHandle == mLabelItemHandle) { string lValue = StringUtils.ObjectToString(aItemValue); if (lValue.Equals(mLabel, StringComparison.Ordinal) == false) { mLabel = lValue; updatePanelBitmap(); raisePropertiesChanged(); } return; } if (aItemHandle == mRotateItemHandle) { float lValue; try { lValue = Convert.ToSingle(aItemValue); } catch (Exception lExc) { throw new ArgumentException("Ratation angle value conversion error. ", lExc); } if (ValuesCompare.isNotEqual(mRotate, lValue)) { mRotate = lValue; updatePanelBitmap(); raisePropertiesChanged(); } return; } }
private void MSession_Notification(Session aSession, NotificationEventArgs aNotificationEventArgs) { if (mConnected == false || mItemList.Count == 0) { return; } var lMessage = aNotificationEventArgs.NotificationMessage; if (lMessage.NotificationData.Count == 0) { return; } var lDataChanges = lMessage.GetDataChanges(false); MonitoredItem lMItem; DataItem lItem; int lCount = lDataChanges.Count; for (int i = 0; i < lCount; i++) { mItemListLock.EnterReadLock(); //======================================== try { lMItem = mSubscription.FindItemByClientHandle(lDataChanges[i].ClientHandle); if (lMItem != null) { lItem = lMItem.Handle as DataItem; if (lDataChanges[i].Value.StatusCode != lItem.StatusCode) { lItem.StatusCode = lDataChanges[i].Value.StatusCode; lItem.raisePropertiesChanged(); } if (lDataChanges[i].Value.Value != null) { if (ValuesCompare.isNotEqual(lItem.mValue, lDataChanges[i].Value.Value)) { lItem.mValue = lDataChanges[i].Value.Value; if (lItem.Access.HasFlag(EAccess.READ)) { lItem.raiseValueChanged(); } } } } } catch (Exception lExc) { raiseConnectionError("Error updating values. " + lExc.ToString()); } finally { //======================================== mItemListLock.ExitReadLock(); } } }
public void setValueFromPLC(byte[] aBytes) { if (mNeedWrite) { return; } bool lValueChanged = false; object lNewValue = aBytes; if (mLength == 1) { if (mDataType == EWordlen.S7_Bit) { lNewValue = (aBytes[0] > 0); } else if (mDataType == EWordlen.S7_Byte) { if (mSigned) { lNewValue = unchecked ((sbyte)aBytes[0]); } else { lNewValue = aBytes[0]; } } else if (mDataType == EWordlen.S7_Word) { Array.Reverse(aBytes); if (mSigned) { lNewValue = BitConverter.ToInt16(aBytes, 0); } else { lNewValue = BitConverter.ToUInt16(aBytes, 0); } } else if (mDataType == EWordlen.S7_DoubleWord) { Array.Reverse(aBytes); if (mFloatingP) { lNewValue = BitConverter.ToSingle(aBytes, 0); } else { if (mSigned) { lNewValue = BitConverter.ToInt32(aBytes, 0); } else { lNewValue = BitConverter.ToUInt32(aBytes, 0); } } } } else { if (mDataType == EWordlen.S7_Byte) { if (mSigned) { sbyte[] lArray = new sbyte[mLength]; for (int i = 0; i < mLength; i++) { lArray[i] = unchecked ((sbyte)aBytes[i]); } lNewValue = lArray; } else { lNewValue = aBytes; } } else if (mDataType == EWordlen.S7_Word) { byte[] lValue = new byte[2]; int lIndex = 0; if (mSigned) { short[] lArray = new short[mLength]; for (int i = 0; i < mLength; i++) { Array.Copy(aBytes, lIndex, lValue, 0, 2); Array.Reverse(lValue); lArray[i] = BitConverter.ToInt16(lValue, 0); lIndex = lIndex + 2; } lNewValue = lArray; } else { ushort[] lArray = new ushort[mLength]; for (int i = 0; i < mLength; i++) { Array.Copy(aBytes, lIndex, lValue, 0, 2); Array.Reverse(lValue); lArray[i] = BitConverter.ToUInt16(lValue, 0); lIndex = lIndex + 2; } lNewValue = lArray; } } else if (mDataType == EWordlen.S7_DoubleWord) { byte[] lValue = new byte[4]; int lIndex = 0; if (mFloatingP) { float[] lArray = new float[mLength]; for (int i = 0; i < mLength; i++) { Array.Copy(aBytes, lIndex, lValue, 0, 4); Array.Reverse(lValue); lArray[i] = BitConverter.ToSingle(lValue, 0); lIndex = lIndex + 4; } lNewValue = lArray; } else { if (mSigned) { int[] lArray = new int[mLength]; for (int i = 0; i < mLength; i++) { Array.Copy(aBytes, lIndex, lValue, 0, 4); Array.Reverse(lValue); lArray[i] = BitConverter.ToInt32(lValue, 0); lIndex = lIndex + 4; } lNewValue = lArray; } else { uint[] lArray = new uint[mLength]; for (int i = 0; i < mLength; i++) { Array.Copy(aBytes, lIndex, lValue, 0, 4); Array.Reverse(lValue); lArray[i] = BitConverter.ToUInt32(lValue, 0); lIndex = lIndex + 4; } lNewValue = lArray; } } } } Monitor.Enter(mValueLock); //========================================= try { if (mNeedWrite) { return; } if (ValuesCompare.isNotEqual(mValue, lNewValue)) { mValue = lNewValue; lValueChanged = true; } } finally { //========================================= Monitor.Exit(mValueLock); } if (lValueChanged) { raiseValueChanged(); } }