Пример #1
0
 public void                     setMaxMinValues(double aMaxValue, double aMinValue)
 {
     if (aMaxValue <= aMinValue)
     {
         throw new ArgumentException("Maximum value has to be greater than minimum. ");
     }
     mValueScale.setProperties(27648, 0, aMaxValue, aMinValue);
 }
Пример #2
0
        public void         loadFromXML(XmlTextReader aXMLTextReader)
        {
            var    lReader = new XMLAttributeReader(aXMLTextReader);
            double lInMax  = lReader.getAttribute <Double>("InMax");
            double lInMin  = lReader.getAttribute <Double>("InMin");
            double lOutMax = lReader.getAttribute <Double>("OutMax");
            double lOutMin = lReader.getAttribute <Double>("OutMin");

            mValueScale.setProperties(lInMax, lInMin, lOutMax, lOutMin);
        }
        private void            okCancelButton_ButtonClick(object aSender, EventArgs aEventArgs)
        {
            try
            {
                double lInMax  = StringUtils.toDouble(textBox_InMax.Text);
                double lInMin  = StringUtils.toDouble(textBox_InMin.Text);
                double lOutMax = StringUtils.toDouble(textBox_OutMax.Text);
                double lOutMin = StringUtils.toDouble(textBox_OutMin.Text);

                mValueScale.setProperties(lInMax, lInMin, lOutMax, lOutMin);

                Close();
            }
            catch (Exception lExc)
            {
                MessageForm.showMessage(lExc.Message, this);
            }
        }
Пример #4
0
        public void                                         loadFromXML(XmlTextReader aXMLTextReader)
        {
            var lReader  = new XMLAttributeReader(aXMLTextReader);
            var lChecker = new RepeatItemNameChecker();

            string lItem = lReader.getAttribute <String>("InputItem");

            lChecker.addItemName(lItem);
            mInValueItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("OutputItem");
            lChecker.addItemName(lItem);
            mOutValueItemHandle = mItemBrowser.getItemHandleByName(lItem);

            double lInMax  = lReader.getAttribute <Double>("MaxInputValue");
            double lInMin  = lReader.getAttribute <Double>("MinInputValue");
            double lOutMax = lReader.getAttribute <Double>("MaxOutputValue");
            double lOutMin = lReader.getAttribute <Double>("MinOutputValue");

            mValueScale.setProperties(lInMax, lInMin, lOutMax, lOutMin);
        }
        public void                                         loadFromXML(XmlTextReader aXMLTextReader)
        {
            var lReader  = new XMLAttributeReader(aXMLTextReader);
            var lChecker = new RepeatItemNameChecker();

            string lItem = lReader.getAttribute <String>("Item");

            lChecker.addItemName(lItem);
            mValueItemHandle = mItemBrowser.getItemHandleByName(lItem);

            double lPMax   = lReader.getAttribute <Double>("MaxPhysicalValue");
            double lPMin   = lReader.getAttribute <Double>("MinPhysicalValue");
            double lRawMax = lReader.getAttribute <Double>("MaxRawValue");
            double lRawMin = lReader.getAttribute <Double>("MinRawValue");

            mValueScale.setProperties(lRawMax, lRawMin, lPMax, lPMin);

            mFaultValue = lReader.getAttribute <Double>("FaultValue", mFaultValue);
            if (mFaultValue > lRawMin && mFaultValue < lRawMax)
            {
                throw new ArgumentException("Fault value is inside normal range. ");
            }

            mUnits = lReader.getAttribute <String>("Units", mUnits);

            #region Thresholds

            if (aXMLTextReader.IsEmptyElement == false)
            {
                aXMLTextReader.Read();
                if (aXMLTextReader.Name.Equals("Thresholds", StringComparison.Ordinal))
                {
                    if (aXMLTextReader.IsEmptyElement == false)
                    {
                        List <int>           lItems      = new List <int>();
                        List <double>        lValues     = new List <double>();
                        List <ValuesCompare> lOperations = new List <ValuesCompare>();
                        double lValue;

                        aXMLTextReader.Read();
                        while (aXMLTextReader.Name.Equals("Threshold", StringComparison.Ordinal))
                        {
                            lOperations.Add(new ValuesCompare(lReader.getAttribute <String>("Operation")));

                            lValue = lReader.getAttribute <Double>("Value");
                            if (lValue > mValueScale.OutMax)
                            {
                                throw new ArgumentException("Threshold value is more than maximum of physical value. ");
                            }
                            if (lValue < mValueScale.OutMin)
                            {
                                throw new ArgumentException("Threshold value is less than minimum of physical value. ");
                            }
                            lValues.Add(lValue);

                            lItem = lReader.getAttribute <String>("Item");
                            lChecker.addItemName(lItem);
                            lItems.Add(mItemBrowser.getItemHandleByName(lItem));

                            aXMLTextReader.Read();
                        }

                        if (lOperations.Count != 0)
                        {
                            mThdItemHandles = lItems.ToArray();
                            mThdItemValues  = new bool[lOperations.Count];
                            mThdValues      = lValues.ToArray();
                            mThdOperations  = lOperations.ToArray();
                        }
                    }

                    aXMLTextReader.Read();
                }
            }

            #endregion
        }
        public void                                         loadFromXML(XmlTextReader aXMLTextReader)
        {
            var    lReader = new XMLAttributeReader(aXMLTextReader);
            var    lChecker = new RepeatItemNameChecker();
            double lMax, lMin;

            string lItem = lReader.getAttribute <String>("StartCMD", "");

            lChecker.addItemName(lItem);
            mStartCMDItemHandle = mItemBrowser.getItemHandleByName(lItem);

            mUseOneCommand = lReader.getAttribute <Boolean>("UseOneCMD", mUseOneCommand);

            lItem = lReader.getAttribute <String>("StopCMD", "");
            lChecker.addItemName(lItem);
            mStopCMDItemHandle = mItemBrowser.getItemHandleByName(lItem);

            StartMS = lReader.getAttribute <UInt32>("StartMS", mStartMS);
            StopMS  = lReader.getAttribute <UInt32>("StopMS", mStopMS);

            lItem = lReader.getAttribute <String>("SpeedCMD", "");
            lChecker.addItemName(lItem);
            mSpeedCMDItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lMax = lReader.getAttribute <Double>("SpeedCMDMax", mSpeedCMDScale.InMax);
            lMin = lReader.getAttribute <Double>("SpeedCMDMin", mSpeedCMDScale.InMin);
            mSpeedCMDScale.setProperties(lMax, lMin, 100.0D, 0.0D);

            lItem = lReader.getAttribute <String>("Moving", "");
            lChecker.addItemName(lItem);
            mMovingItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("Alarm", "");
            lChecker.addItemName(lItem);
            mAlarmItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("Reverse", "");
            lChecker.addItemName(lItem);
            mReverseItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("Acceleration", "");
            lChecker.addItemName(lItem);
            mAccelerationItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("Braking", "");
            lChecker.addItemName(lItem);
            mBrakingItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("Speed", "");
            lChecker.addItemName(lItem);
            mSpeedItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lMax = lReader.getAttribute <Double>("SpeedMax", mSpeedScale.InMax);
            lMin = lReader.getAttribute <Double>("SpeedMin", mSpeedScale.InMin);
            mSpeedScale.setProperties(lMax, lMin, 100.0D, 0.0D);

            lItem = lReader.getAttribute <String>("Forward", "");
            lChecker.addItemName(lItem);
            mForwardItemHandle = mItemBrowser.getItemHandleByName(lItem);

            lItem = lReader.getAttribute <String>("Backward", "");
            lChecker.addItemName(lItem);
            mBackwardItemHandle = mItemBrowser.getItemHandleByName(lItem);
        }
 public void                 setMaxMinValues(double aMaxValue, double aMinValue)
 {
     mValueScale.setProperties(27648, 0, aMaxValue, aMinValue);
 }