public object convertValue(object aValue)
{
double lValue;
try
{
lValue = Convert.ToDouble(aValue);
}
catch (Exception lExc)
{
throw new InvalidOperationException("Value conversion error. " + lExc.Message, lExc);
}
return(mValueScale.scale(lValue));
}
private void sliderControl_ValueChanged(object aSender, EventArgs aEventArgs)
{
if (mNoUpdate)
{
return;
}
double lValue = mValueScale.scale(sliderControl.Value);
if (ValuesCompare.NotEqualDelta1.compare(mValue, lValue))
{
mValue = lValue;
mDoubleValue.ValueDouble = lValue;
}
checkFault();
}
public void onItemValueChange(int aItemHandle, object aItemValue)
{
if (aItemHandle == mValueItemHandle)
{
double lValue;
try
{
lValue = mValueScale.scale(Convert.ToDouble(aItemValue));
}
catch (Exception lExc)
{
throw new ArgumentException("Input value conversion error. ", lExc);
}
if (mFault)
{
if (ValuesCompare.NotEqualDelta1.compare(lValue, mFaultValue))
{
mValueChanged = true;
}
}
else
{
mFilter.addInValue(lValue);
if (mFilter.Ignore == false)
{
if (ValuesCompare.NotEqualDelta1.compare(lValue, mValue))
{
if (lValue <= mValueScale.OutMax && lValue >= mValueScale.OutMin)
{
setValueOutside(lValue);
}
}
}
}
return;
}
}
public void onItemValueChange(int aItemHandle, object aItemValue)
{
if (aItemHandle == mValueItemHandle)
{
double lValue;
try
{
lValue = mValueScale.scale(Convert.ToDouble(aItemValue));
}
catch (Exception lExc)
{
throw new ArgumentException("Input value conversion error. ", lExc);
}
if (mFault)
{
if (ValuesCompare.NotEqualDelta1.compare(lValue, mFaultValue))
{
mValueChanged = true;
}
}
else
{
mFilter.addInValue(lValue);
if (mFilter.Ignore == false)
{
if (ValuesCompare.NotEqualDelta1.compare(lValue, mValue))
{
if (lValue <= mValueScale.OutMax && lValue >= mValueScale.OutMin)
{
setValueOutside(lValue);
}
}
}
}
return;
}
for (int i = 0; i < mThdItemHandles.Length; i++)
{
if (aItemHandle == mThdItemHandles[i])
{
bool lValue;
try
{
lValue = Convert.ToBoolean(aItemValue);
}
catch (Exception lExc)
{
Log.Error("Value conversion error for threshold. " + lExc.Message, lExc.ToString());
mValueChanged = true;
continue;
}
if (lValue != mThdItemValues[i])
{
mValueChanged = true;
}
return;
}
}
}
public void onItemValueChange(int aItemHandle, object aItemValue)
{
if (aItemHandle == mInValueItemHandle)
{
double lNewInValue;
double lNewOutValue;
try
{
lNewInValue = Convert.ToDouble(aItemValue);
if (lNewInValue > mValueScale.InMax || lNewInValue < mValueScale.InMin)
{
throw new ArgumentException("Value is out of range. ");
}
lNewOutValue = mValueScale.scale(lNewInValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Input value conversion error. ", lExc);
}
mInValue = lNewInValue;
if (ValuesCompare.NotEqualDelta1.compare(lNewOutValue, mOutValue))
{
mOutValue = lNewOutValue;
mOutValueChanged = true;
mValueChanged = true;
raiseValuesChanged();
}
return;
}
if (aItemHandle == mOutValueItemHandle)
{
double lNewInValue;
double lNewOutValue;
try
{
lNewOutValue = Convert.ToDouble(aItemValue);
if (lNewOutValue > mValueScale.OutMax || lNewOutValue < mValueScale.OutMin)
{
throw new ArgumentException("Value is out of range. ");
}
lNewInValue = mValueScale.unscale(lNewOutValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Output value conversion error. ", lExc);
}
mOutValue = lNewOutValue;
if (ValuesCompare.NotEqualDelta1.compare(lNewInValue, mInValue))
{
mInValue = lNewInValue;
mInValueChanged = true;
mValueChanged = true;
raiseValuesChanged();
}
return;
}
}
public void onItemValueChange(int aItemHandle, object aItemValue)
{
if (aItemHandle == mStartCMDItemHandle)
{
bool lValue;
try
{
lValue = Convert.ToBoolean(aItemValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Value conversion error for conveyor 'Start' command. ", lExc);
}
if (mStartCMD != lValue)
{
mStartCMD = lValue;
raiseValuesChanged();
}
return;
}
if (aItemHandle == mStopCMDItemHandle)
{
bool lValue;
try
{
lValue = Convert.ToBoolean(aItemValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Value conversion error for conveyor 'Stop' command. ", lExc);
}
if (mStopCMD != lValue)
{
mStopCMD = lValue;
raiseValuesChanged();
}
return;
}
if (aItemHandle == mSpeedCMDItemHandle)
{
double lValue;
try
{
lValue = mSpeedCMDScale.scale(Convert.ToDouble(aItemValue));
}
catch (Exception lExc)
{
throw new ArgumentException("Value conversion error for conveyor 'Speed' command. ", lExc);
}
if (lValue < 0.0D || lValue > 100.0D)
{
throw new ArgumentException("Value of the 'Speed' command is out of range (0..100%). ");
}
if (ValuesCompare.NotEqualDelta1.compare(mSpeedCMD, lValue))
{
mSpeedCMD = lValue;
raiseValuesChanged();
}
return;
}
if (aItemHandle == mMovingItemHandle)
{
bool lValue;
try
{
lValue = Convert.ToBoolean(aItemValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Value conversion error for conveyor 'Moving' state. ", lExc);
}
if (mMoving != lValue)
{
evaluate(lValue);
raiseValuesChanged();
}
return;
}
if (aItemHandle == mAlarmItemHandle)
{
bool lValue;
try
{
lValue = Convert.ToBoolean(aItemValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Value conversion error for conveyor 'Alarm' state. ", lExc);
}
if (mAlarm != lValue)
{
mAlarm = lValue;
raiseValuesChanged();
}
return;
}
if (aItemHandle == mReverseItemHandle)
{
bool lValue;
try
{
lValue = Convert.ToBoolean(aItemValue);
}
catch (Exception lExc)
{
throw new ArgumentException("Value conversion error for conveyor 'Reverse' state. ", lExc);
}
if (mReverse != lValue)
{
mReverse = lValue;
raiseValuesChanged();
}
return;
}
}
