C# VPort.GetInfo方法代码示例

        public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
        {
            string message;
            string sensorData;
            string sensorTag = senderPort.GetInfo().GetFriendlyName() + roleName;

            lock (this)
            {
                if (roleName.Contains(RoleSensor.RoleName) && opName.Equals(RoleSensor.OpGetName))
                {
                        byte rcvdNum = (byte) (int) retVals[0].Value();
                        sensorData = rcvdNum.ToString();

                }
                else if (roleName.Contains(RoleSensorMultiLevel.RoleName) && opName.Equals(RoleSensorMultiLevel.OpGetName))
                {
                    double rcvdNum = (double) retVals[0].Value();
                    sensorData = rcvdNum.ToString();
                }
                else
                {
                    sensorData = String.Format("Invalid role->op {0}->{1} from {2}", roleName, opName, sensorTag);
                }
            }

            //Write to the stream
            WriteToStream(sensorTag, sensorData);
            //Create local list of alerts for display
            message = String.Format("{0} {1},{2}", DateTime.Now, sensorTag, sensorData);
            this.receivedMessageList.Add(message);
            //Log
            logger.Log("{0},{1}", this.ToString(), message);
        }

        /// <summary>
        /// Does the given port contain the given role
        /// </summary>
        /// <param name="port"></param>
        /// <param name="roleName"></param>
        /// <returns></returns>
        public static bool ContainsRole(VPort port, string roleName)
        {
            foreach (VRole role in port.GetInfo().GetRoles())
            {
                if (ContainsRole(role.Name(), roleName))
                    return true;
            }

            return false;
        }

 public override void PortDeregistered(VPort port)
 {
     lock (this)
     {
         if (accessibleDummyPorts.Contains(port))
         {
             accessibleDummyPorts.Remove(port);
             logger.Log("{0} deregistered port {1}", this.ToString(), port.GetInfo().ModuleFacingName());
         }
     }
 }

        private void StopRecording(VPort cameraPort, bool force)
        {
            bool stopConditionMet = false;
            CameraInfo cameraInfo = registeredCameras[cameraPort];

            //if ((DateTime.Now - registeredCameras[cameraPort].CurrVideoStartTime).TotalMinutes >=
            //            MAX_VIDEO_CLIP_LEN_IN_MINUTES)

            if (DateTime.Now >= registeredCameras[cameraPort].CurrVideoEndTime)
            {
                stopConditionMet = true;
            }

            if ((force || stopConditionMet) && (cameraInfo.VideoWriter != null))
            {
                string cameraName = cameraPort.GetInfo().GetFriendlyName();
                VideoWriter VideoWriter = cameraInfo.VideoWriter;

                SafeThread helper = new SafeThread(delegate() { StopRecordingHelper(VideoWriter, cameraName); },
                                                    "stoprecordinghelper-" + cameraName, logger);
                helper.Start();

                cameraInfo.RecordVideo = false;
                cameraInfo.VideoWriter = null;
                cameraInfo.CurrVideoStartTime = DateTime.MinValue;
                cameraInfo.CurrVideoEndTime = DateTime.MinValue;

                if (stopConditionMet)
                {
                    logger.Log("Stop recording because the clip time has elapsed for {0}",
                            cameraPort.GetInfo().GetFriendlyName());
                }
                else
                {
                    logger.Log("Stop recording for {0}", cameraPort.GetInfo().GetFriendlyName());
                }
            }
        }

        // Starts a new recording if there isn't one already under way
        private void StartRecording(VPort cameraPort, int videoWidth, int videoHeight, int videoFPSNum, int videoFPSDen, int videoEncBitrate)
        {
            if (registeredCameras[cameraPort].VideoWriter != null)
            {
                return;
            }

            logger.Log("Started new clip for {0}", cameraPort.GetInfo().GetFriendlyName());
            CameraInfo cameraInfo = registeredCameras[cameraPort];

            string fileName = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Video_MP4);

            if (null == registeredCameras[cameraPort].VideoWriter)
            {
                registeredCameras[cameraPort].VideoWriter = new VideoWriter();
            }

            cameraInfo.CurrVideoStartTime = DateTime.Now;
            cameraInfo.CurrVideoEndTime = cameraInfo.CurrVideoStartTime + DEFAULT_VIDEO_CLIP_LEN;

            int result = cameraInfo.VideoWriter.Init(fileName, videoWidth, videoHeight, videoFPSNum, videoFPSDen, videoEncBitrate);

            if (result != 0)
            {
                string message = String.Format("Failed to start recording for {0} at {1}. Error code = {2}",
                                                cameraPort.GetInfo().GetFriendlyName(), DateTime.Now, result);
                logger.Log(message);
            }
        }

        public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
        {
            if (registeredCameras.ContainsKey(senderPort))
            {
                if (retVals.Count >= 1 && retVals[0].Value() != null)
                {
                    byte[] imageBytes = (byte[])retVals[0].Value();

                    lock (this)
                    {
                        registeredCameras[senderPort].LastImageBytes = imageBytes;

                        if (registeredCameras[senderPort].RecordVideo ||
                            registeredCameras[senderPort].EnableObjectTrigger)
                        {
                            bool addFrame = false;
                            Rectangle rectObject = new Rectangle(0, 0, 0, 0);
                            MemoryStream stream = new MemoryStream(imageBytes);
                            Bitmap image = null;
                            image = (Bitmap)Image.FromStream(stream);
                            if (null != registeredCameras[senderPort].BitmapImage)
                            {
                                registeredCameras[senderPort].BitmapImage.Dispose();
                                registeredCameras[senderPort].BitmapImage = null;
                            }
                            registeredCameras[senderPort].BitmapImage = image;

                            //lets check if the image is what we expect
                            if (image.PixelFormat != PixelFormat.Format24bppRgb)
                            {
                                string message = String.Format("Image format from {0} is not correct. PixelFormat: {1}",
                                                                senderPort.GetInfo().GetFriendlyName(), image.PixelFormat);
                                logger.Log(message);

                                return;
                            }

                            // stop if needed
                            StopRecording(senderPort, false /* force*/);

                            //// if recording is underway don't bother that, it will stop after that clip time lapses
                            //// if recording needs to be done only on motion (object) triggers, check with the result of the object
                            //// detector above
                            //if (registeredCameras[senderPort].RecordVideo)
                            //{
                            //    //if record video is still true, see if we need to add his frame
                            //    if (registeredCameras[senderPort].VideoWriter != null || !registeredCameras[senderPort].EnableObjectTrigger)
                            //    {
                            //        addFrame = true;
                            //    }
                            //    else
                            //    {
                            //        if (registeredCameras[senderPort].ObjectFound)
                            //            addFrame = true;
                            //    }
                            //}

                            if (registeredCameras[senderPort].RecordVideo)
                            {
                                addFrame = true;
                            }
                            else
                            {
                                if (registeredCameras[senderPort].EnableObjectTrigger &&
                                    registeredCameras[senderPort].ObjectFound)
                                    addFrame = true;
                            }

                            if (addFrame)
                            {

                                StartRecording(senderPort, image.Width, image.Height, VIDEO_FPS_NUM, VIDEO_FPS_DEN, VIDEO_ENC_FRAMERATE);

                                long sampleTime = (DateTime.Now - registeredCameras[senderPort].CurrVideoStartTime).Ticks;

                                AddFrameToVideo(image, senderPort, sampleTime);

                                if (registeredCameras[senderPort].ObjectFound)
                                {
                                    registeredCameras[senderPort].ObjectFound = false;
                                    rectObject = registeredCameras[senderPort].LastObjectRect;
                                    WriteObjectImage(senderPort, image, rectObject, true /* center */);
                                }

                            }
                        }
                    }
                }
                else
                {
                    logger.Log("{0} got null image", this.ToString());
                }
            }
        }

        //, int imgWidth, int imgHeight, Image img)
        // Starts a new recording if there isn't one already under way
        //int i = 0;
        private void TakeImage(VPort cameraPort)
        {
            CameraInfo cameraInfo = registeredCameras[cameraPort];
            Image test = cameraInfo.BitmapImage;

            if (registeredCameras[cameraPort].BitmapImage == null)
            {
                return;
            }

            logger.Log("Taking image for {0}", cameraPort.GetInfo().GetFriendlyName());

            string filepath = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Image_JPEG);

            if (null == filepath)
            {
                logger.Log("GetMediaFileName failed to get a file name, are there more than 10 files of the same name?");
                return;
            }

            //string fileName = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Image_JPEG);
            //test.Save("C:\\Users\\seth\\Pictures\\Camera Roll\\suckmycock" + i + ".bmp", ImageFormat.Bmp);
            test.Save(filepath, ImageFormat.Jpeg);
            //i++;

            //if (registeredCameras[cameraPort].BitmapImage == null)
            //{
            //    return;
            //}

            //logger.Log("Taking image for {0}", cameraPort.GetInfo().GetFriendlyName());

            //Image test = cameraInfo.BitmapImage;

            //string fileName = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Image_JPEG);

            //if (null == registeredCameras[cameraPort].VideoWriter)
            //{
            //    registeredCameras[cameraPort].VideoWriter = new VideoWriter();
            //}

            //cameraInfo.CurrVideoStartTime = DateTime.Now;
            //cameraInfo.CurrVideoEndTime = cameraInfo.CurrVideoStartTime + DEFAULT_VIDEO_CLIP_LEN;

            //int result = cameraInfo.VideoWriter.Init(fileName, videoWidth, videoHeight, videoFPSNum, videoFPSDen, videoEncBitrate);
            //string path = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
            //img.Save(path + "suckmycock.bmp", ImageFormat.Bmp);

            //if (result != 0)
            //{
            //    string message = String.Format("Failed to start recording for {0} at {1}. Error code = {2}",
            //                                    cameraPort.GetInfo().GetFriendlyName(), DateTime.Now, result);
            //    logger.Log(message);
            //}
        }

        private void AddFrameToVideo(Bitmap image, VPort cameraPort, long sampleTime)
        {
            // Lock the bitmap's bits.  
            Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
            BitmapData bmpData = image.LockBits(rect, ImageLockMode.ReadOnly, image.PixelFormat);

            // Get the address of the first line.
            IntPtr ptr = bmpData.Scan0;

            int result;

            unsafe
            {
                result = registeredCameras[cameraPort].VideoWriter.AddFrame((byte*)ptr, 3 * image.Width * image.Height, image.Width, image.Height, sampleTime);
            }

            image.UnlockBits(bmpData);

            if (result != 0)
            {
                string message = String.Format("Failed to add frame for {0}. ResultCode: {1:x}", cameraPort.GetInfo().GetFriendlyName(), ((uint)result));
                logger.Log(message);

            }
        }

        private bool ExtractObjectFromFrame(Bitmap image, VPort cameraPort, ref Rectangle rectObject)
        {
            bool foundObject = false;

            // Lock the bitmap's bits.  
            Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
            BitmapData bmpData = image.LockBits(rect, ImageLockMode.ReadOnly, image.PixelFormat);

            // Get the address of the first line.
            IntPtr ptr = bmpData.Scan0;

            if (null == registeredCameras[cameraPort].ObjectDetector)
            {
                registeredCameras[cameraPort].ObjectDetector = new ObjectDetector();
            }

            unsafe
            {
                if (!registeredCameras[cameraPort].ObjectDetector.IsInitialized())
                {
                    registeredCameras[cameraPort].ObjectDetector.InitializeFromFrame((byte*)ptr, 3 * image.Width * image.Height, image.Width, image.Height, null);
                }
                else
                {
                    rectObject = registeredCameras[cameraPort].ObjectDetector.GetObjectRect((byte*)ptr, 3 * image.Width * image.Height);
                    if (rectObject.Width != 0 && rectObject.Height != 0)
                        foundObject = true;
                }

                if (foundObject)
                {
                    logger.Log("Object detected by camera {0} with co-ordinates X={1}, Y={2}, Width={3}, Height={4}",
                        cameraPort.GetInfo().GetFriendlyName(), rectObject.X.ToString(), rectObject.Y.ToString(), rectObject.Width.ToString(), rectObject.Height.ToString());
                }
            }

            image.UnlockBits(bmpData);

            return foundObject;

        }

        public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
        {
            if (retVals.Count >= 1)
            {
                byte val = (byte) (int) retVals[0].Value();

                //hack for techfest since we are using a multi-level switch as a doorbell
                //if (RoleSwitchMultiLevel.RoleName.Equals(roleName, StringComparison.CurrentCultureIgnoreCase))
                //    val = 0;

                Alert newAlert = new Alert() { TimeTriggered = DateTime.Now,
                                                                 SensorFriendlyName = senderPort.GetInfo().GetFriendlyName(),
                                                                 SensorLocation = senderPort.GetInfo().GetLocation().Name(),
                                                                 Value = val,
                                                                 Acknowledged = false, };

                bool notify = //settings.Mode != AlertMode.none &&
                              IsAlertTime() &&
                              !SuppressAlert(newAlert) &&
                              ((RoleSwitchMultiLevel.RoleName.Equals(roleName, StringComparison.CurrentCultureIgnoreCase) && (val == 99 || val == 0)) ||
                               (RoleSensor.RoleName.Equals(roleName, StringComparison.CurrentCultureIgnoreCase) && val == 255));

                logger.Log("{0}: got notified by {1} [{2}] val = {3} notify = {4}\n",
                           this.ToString(), newAlert.SensorFriendlyName, roleName, val.ToString(), notify.ToString());

                if (notify)
                {
                    InsertAlert(newAlert);
                    GenerateMessage(newAlert);
                }
            }
            else
            {
                logger.Log("{0}: got unexpected retvals [{1}] from {2}", ToString(), retVals.Count.ToString(), senderPort.ToString());
            }
        }

        public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
        {
            timerCount++;
            if (timerCount >= 50)
            {
                timerCount = 0;
                //push_event_check = 0;

                /*
                if (push_event_check == 1)
                {
                    push_event_check = 2; timerCount = 0;
                    recordingController = 2;
                    Console.WriteLine(this.ToString() + " : Stopped Recording");
                }*/
            }

            if (registeredCameras.ContainsKey(senderPort))
            {
                if (retVals.Count >= 1 && retVals[0].Value() != null)
                {
                    byte[] imageBytes = (byte[])retVals[0].Value();

                    lock (this)
                    {
                        if (recordingController == 1)
                        {
                            registeredCameras[senderPort].RecordVideo = true;
                            recordingController = 0;
                        }
                        else if (recordingController == 2)
                        {
                            StopRecording(senderPort, true);
                            recordingController = 0;
                        }

                        registeredCameras[senderPort].LastImageBytes = imageBytes;

                        if (registeredCameras[senderPort].RecordVideo ||
                            registeredCameras[senderPort].EnableObjectTrigger)
                        {
                            bool addFrame = false;
                            Rectangle rectObject = new Rectangle(0, 0, 0, 0);
                            MemoryStream stream = new MemoryStream(imageBytes);
                            Bitmap image = null;
                            image = (Bitmap)Image.FromStream(stream);
                            if (null != registeredCameras[senderPort].BitmapImage)
                            {
                                registeredCameras[senderPort].BitmapImage.Dispose();
                                registeredCameras[senderPort].BitmapImage = null;
                            }
                            registeredCameras[senderPort].BitmapImage = image;

                            //lets check if the image is what we expect
                            if (image.PixelFormat != PixelFormat.Format24bppRgb)
                            {
                                string message = String.Format("Image  format from {0} is not correct. PixelFormat: {1}",
                                                                senderPort.GetInfo().GetFriendlyName(), image.PixelFormat);
                                logger.Log(message);

                                return;
                            }

                            // stop if needed
                            StopRecording(senderPort, false /* force*/);

                            //// if recording is underway don't bother that, it will stop after that clip time lapses
                            //// if recording needs to be done only on motion (object) triggers, check with the result of the object
                            //// detector above
                            //if (registeredCameras[senderPort].RecordVideo)
                            //{
                            //    //if record video is still true, see if we need to add his frame
                            //    if (registeredCameras[senderPort].VideoWriter != null || !registeredCameras[senderPort].EnableObjectTrigger)
                            //    {
                            //        addFrame = true;
                            //    }
                            //    else
                            //    {
                            //        if (registeredCameras[senderPort].ObjectFound)
                            //            addFrame = true;
                            //    }
                            //}

                            if (registeredCameras[senderPort].RecordVideo)
                            {
                                addFrame = true;
                            }
                            else
                            {
                                if (registeredCameras[senderPort].EnableObjectTrigger &&
                                    registeredCameras[senderPort].ObjectFound)
                                    addFrame = true;
                            }

                            if (addFrame)
                            {

                                StartRecording(senderPort, image.Width, image.Height, VIDEO_FPS_NUM, VIDEO_FPS_DEN, VIDEO_ENC_FRAMERATE);

                                long sampleTime = (DateTime.Now - registeredCameras[senderPort].CurrVideoStartTime).Ticks;
//.........这里部分代码省略.........

        /// <summary>
        ///  Called when a new port is deregistered with the platform
        /// </summary>
        /// <param name="port"></param>
        public override void PortDeregistered(VPort port)
        {
            lock (this)
            {
                if (Role.ContainsRole(port, RoleCamera.RoleName))
                {
                    if (registeredCameras.ContainsKey(port))
                    {
                        ForgetCamera(port);
                        logger.Log("{0} deregistered camera port {1}", this.ToString(), port.GetInfo().ModuleFacingName());
                    }
                }
                else if (accessibleDummyPorts.Contains(port))
                {
                    accessibleDummyPorts.Remove(port);
                    logger.Log("{0} deregistered port {1}", this.ToString(), port.GetInfo().ModuleFacingName());
                }
                else if (registeredSwitches.ContainsKey(port))
                {
                    ForgetSwitch(port);
                }

            }
        }

        /// <summary>
        ///  Called when a new port is registered with the platform
        /// </summary>
        /// <param name="port"></param>
        public override void PortRegistered(VPort port)
        {
            lock (this)
            {
                if (Role.ContainsRole(port, RoleCamera.RoleName))
                {
                    if (!registeredCameras.ContainsKey(port))
                    {
                        InitCamera(port);
                    }
                    else
                    {
                        //the friendly name of the port might have changed. update that.
                        string oldFriendlyName = null;

                        foreach (var pair in cameraFriendlyNames)
                        {
                            if (pair.Value.Equals(port) &&
                                !pair.Key.Equals(port.GetInfo().GetFriendlyName()))
                            {
                                oldFriendlyName = pair.Key;
                                break;
                            }
                        }

                        if (oldFriendlyName != null)
                        {
                            cameraFriendlyNames.Remove(oldFriendlyName);
                            cameraFriendlyNames.Add(port.GetInfo().GetFriendlyName(), port);
                        }
                    }

                }
                else if (!accessibleDummyPorts.Contains(port) &&
                    Role.ContainsRole(port, RoleDummy.RoleName) &&
                    GetCapabilityFromPlatform(port) != null)
                {
                    accessibleDummyPorts.Add(port);

                    logger.Log("{0} added port {1}", this.ToString(), port.ToString());

                    if (Subscribe(port, RoleDummy.Instance, RoleDummy.OpEchoSubName))
                        logger.Log("{0} subscribed to port {1}", this.ToString(), port.ToString());
                    else
                        logger.Log("failed to subscribe to port {1}", this.ToString(), port.ToString());
                }
                else if (Role.ContainsRole(port, RoleSwitchMultiLevel.RoleName) ||
                    Role.ContainsRole(port, RoleSwitchBinary.RoleName) ||
                    Role.ContainsRole(port, RoleLightColor.RoleName))
                {
                    if (!registeredSwitches.ContainsKey(port) &&
                        GetCapabilityFromPlatform(port) != null)
                    {
                        var switchType = (Role.ContainsRole(port, RoleSwitchMultiLevel.RoleName)) ? SwitchType.Multi : SwitchType.Binary;

                        bool colored = Role.ContainsRole(port, RoleLightColor.RoleName);

                        InitSwitch(port, switchType, colored);
                    }

                }

                else if (Role.ContainsRole(port, RoleSpeechReco.RoleName))
                {

                    if (!speechPorts.Contains(port) &&
                        GetCapabilityFromPlatform(port) != null)
                    {

                        speechPorts.Add(port);

                        logger.Log("SwitchController:{0} added speech port {1}", this.ToString(), port.ToString());


                        //TODO Call it with phrases we care about - FOR NOW HARD CODED in Kinect driver
                        //  var retVal = Invoke(port, RoleSpeechReco.Instance, RoleSpeechReco.OpSetSpeechPhraseName, new ParamType(ParamType.SimpleType.text, "on"));

                        //subscribe to speech reco
                        if (Subscribe(port, RoleSpeechReco.Instance, RoleSpeechReco.OpPhraseRecognizedSubName))
                            logger.Log("{0} subscribed to port {1}", this.ToString(), port.ToString());
                    }
                }
            }
        }

        void ForgetSwitch(VPort switchPort)
        {
            switchFriendlyNames.Remove(switchPort.GetInfo().GetFriendlyName());

            registeredSwitches.Remove(switchPort);

            logger.Log("{0} removed switch/light port {1}", this.ToString(), switchPort.ToString());
        }

        void InitSwitch(VPort switchPort, SwitchType switchType, bool isColored)
        {

            logger.Log("{0} adding switch {1} {2}", this.ToString(), switchType.ToString(), switchPort.ToString());

            SwitchInfo switchInfo = new SwitchInfo();
            switchInfo.Capability = GetCapability(switchPort, Constants.UserSystem);
            switchInfo.Level = 0;
            switchInfo.Type = switchType;

            switchInfo.IsColored = isColored;
            switchInfo.Color = Color.Black;

            registeredSwitches.Add(switchPort, switchInfo);

            string switchFriendlyName = switchPort.GetInfo().GetFriendlyName();
            switchFriendlyNames.Add(switchFriendlyName, switchPort);

            if (switchInfo.Capability != null)
            {
                IList<VParamType> retVals;

                if (switchType == SwitchType.Multi)
                {
                    retVals = switchPort.Invoke(RoleSwitchMultiLevel.RoleName, RoleSwitchMultiLevel.OpGetName, null,
                    ControlPort, switchInfo.Capability, ControlPortCapability);

                    switchPort.Subscribe(RoleSwitchMultiLevel.RoleName, RoleSwitchMultiLevel.OpGetName, ControlPort, switchInfo.Capability, ControlPortCapability);

                    if (retVals[0].Maintype() < 0)
                    {
                        logger.Log("SwitchController could not get current level for {0}", switchFriendlyName);
                    }
                    else
                    {
                        switchInfo.Level = (double)retVals[0].Value();
                    }
                }
                else
                {
                    retVals = switchPort.Invoke(RoleSwitchBinary.RoleName, RoleSwitchBinary.OpGetName, null,
                    ControlPort, switchInfo.Capability, ControlPortCapability);

                    switchPort.Subscribe(RoleSwitchBinary.RoleName, RoleSwitchBinary.OpGetName, ControlPort, switchInfo.Capability, ControlPortCapability);

                    if (retVals[0].Maintype() < 0)
                    {
                        logger.Log("SwitchController could not get current level for {0}", switchFriendlyName);
                    }
                    else
                    {
                        bool boolLevel = (bool)retVals[0].Value();
                        switchInfo.Level = (boolLevel) ? 1 : 0;
                    }
                }

                //fix the color up now

                if (isColored)
                {
                    var retValsColor = switchPort.Invoke(RoleLightColor.RoleName, RoleLightColor.OpGetName, null,
                                                          ControlPort, switchInfo.Capability, ControlPortCapability);

                    switchPort.Subscribe(RoleLightColor.RoleName, RoleLightColor.OpGetName, ControlPort, switchInfo.Capability, ControlPortCapability);

                    if (retVals[0].Maintype() < 0)
                    {
                        logger.Log("SwitchController could not get color for {0}", switchFriendlyName);
                    }
                    else
                    {
                        byte red, green, blue;

                        red = Math.Min(Math.Max((byte)(int)retValsColor[0].Value(), (byte)0), (byte)255);
                        green = Math.Min(Math.Max((byte)(int)retValsColor[1].Value(), (byte)0), (byte)255);
                        blue = Math.Min(Math.Max((byte)(int)retValsColor[2].Value(), (byte)0), (byte)255);

                        switchInfo.Color = Color.FromArgb(red, green, blue);
                    }
                }
            }
        }