コード例 #1
0
ファイル: Form1.cs プロジェクト: moonspeak/lightbot-net-app
        private async void DoBlinkLoop()
        {
            if (await client.CheckConnection() == true)
            {
                var commandLoopOn = new LightCommand();
                commandLoopOn.Effect = Effect.ColorLoop;
                var commandLoopOff = new LightCommand();
                commandLoopOff.Effect = Effect.None;
                var commandBlink = new LightCommand();
                commandBlink.Alert = Alert.Multiple;

                Q42.HueApi.Models.Groups.Group selectedGroup = getSelectedGroup();

                await client.SendCommandAsync(commandLoopOn, selectedGroup.Lights);

                await client.SendCommandAsync(commandBlink, selectedGroup.Lights);

                int loopDuration = Convert.ToInt32(Properties.Settings.Default.colorLoopDuration) * 1000;

                Thread.Sleep(loopDuration);
                await client.SendCommandAsync(commandLoopOff, selectedGroup.Lights);

                logEvent("Doing a Color Looping blink", true);
            }
        }
コード例 #2
0
        public void SetBulbColor(int redComponent, int greenComponent, int blueComponent, string bulbID = "", Action callbackMethod = null)
        {
            try
            {
                Task setColorTask = new Task(async() =>
                {
                    if ((hueClient != null) &&
                        (await hueClient.CheckConnection() == true))
                    {
                        if (colorBulbs.Count > 0)
                        {
                            List <string> bulbIDs     = new List <string>();
                            LightCommand lightCommand = new LightCommand();

                            if (bulbID == string.Empty)
                            {
                                for (int i = 0; i < colorBulbs.Count; i++)
                                {
                                    bulbIDs.Add(colorBulbs[i].Id);
                                }
                            }
                            else
                            {
                                bulbIDs.Add(bulbID);
                            }

                            lightCommand.TurnOn();
                            lightCommand.SetColor(HueColorConverter.XyFromColor(redComponent, greenComponent, blueComponent).x,
                                                  HueColorConverter.XyFromColor(redComponent, greenComponent, blueComponent).y);

                            lightCommand.Brightness = 200;

                            await hueClient.SendCommandAsync(lightCommand, bulbIDs);
                        }

                        callbackMethod?.Invoke();
                    }
                    else
                    {
                        errorLog += "\r\n\r\n" + DateTime.Now.ToString() + ": Philips Hue bridge is not connected.";

                        callbackMethod?.Invoke();
                    }
                });

                setColorTask.Start();
            }
            catch (Exception setColorException)
            {
                errorLog += "\r\n\r\n" + DateTime.Now.ToString() + ": " + setColorException;

                callbackMethod?.Invoke();
            }
        }
コード例 #3
0
            /// <summary>
            /// Checks connection and adjusts communication delay dynamically.
            /// </summary>
            /// <returns></returns>
            public async Task CheckConnection()
            {
                long startTimestamp   = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
                long deltaTimestamp   = 0;
                long adjustedPing     = 0;
                bool connectionResult = await hueClient.CheckConnection();

                //update connection status
                BridgeConnected = connectionResult;

                if (connectionResult == true)
                {
                    deltaTimestamp = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) - startTimestamp;
                    adjustedPing   = (int)Math.Round((int)deltaTimestamp * bridgecommunicationdelayFactor);

                    if (adjustedPing > bridgecommunicationminimumDelay)
                    {
                        bridgecommunicationDelay = (int)adjustedPing;
                        Log.Write("PhilipsHueController.CheckConnection IP=" + BridgeIP + "... current connection lag =" + deltaTimestamp + "ms, recalibrating from " + bridgecommunicationDelay + "ms -> " + deltaTimestamp + "ms, buffer factor=" + bridgecommunicationdelayFactor + " -> " + adjustedPing + "ms");
                    }
                    else
                    {
                        bridgecommunicationDelay = bridgecommunicationminimumDelay;
                        Log.Write("PhilipsHueController.CheckConnection IP=" + BridgeIP + "... current connection lag =" + deltaTimestamp + "ms, ignoring and using minimum " + bridgecommunicationminimumDelay + "ms to avoid bridge overload");
                    }
                }
                else
                {
                    Log.Write("PhilipsHueController.CheckConnection... lost connection, or unable to connect to bridge using BridgeIP=" + BridgeIP + " and BridgeKey=" + BridgeKey + "... will ignore for now and attempt reconnecting every " + bridgecommunicationPing + "ms");
                }
            }
コード例 #4
0
 public async Task AssertConnected()
 {
     if (!await client.CheckConnection())
     {
         if (string.IsNullOrEmpty(optionsDelegate.CurrentValue.BridgeProperties.ApiKey))
         {
             var          cts           = new CancellationTokenSource();
             const int    cancelAfter   = 120;
             const double retryInterval = 10.0;
             try
             {
                 cts.CancelAfter(cancelAfter * 1000);
                 optionsDelegate.CurrentValue.BridgeProperties.ApiKey = await RegisterApplication(retryInterval, cts.Token);
             }
             catch (Exception e)
             {
                 logger.LogError(e, $"Application failed to register with bridge: timed out after {cancelAfter}s");
                 throw;
             }
         }
         try
         {
             client.Initialize(optionsDelegate.CurrentValue.BridgeProperties.ApiKey);
             logger.LogInformation("Hue client initialised.");
         }
         catch (Exception e)
         {
             logger.LogError($"Failed to initialise Hue client", e);
             throw;
         }
     }
     return;
 }
コード例 #5
0
ファイル: HueInterface.cs プロジェクト: Jingseven/Chromatics
        public async void HueRestoreState()
        {
            var connect = await _client.CheckConnection();

            if (connect)
            {
                foreach (var d in _HueBulbsRestore)
                {
                    try
                    {
                        var state   = d.Value;
                        var command = new LightCommand();
                        command.Brightness       = state.Brightness;
                        command.ColorCoordinates = state.ColorCoordinates;
                        command.ColorTemperature = state.ColorTemperature;
                        command.Hue        = state.Hue;
                        command.On         = state.On;
                        command.Saturation = state.Saturation;

                        await _client.SendCommandAsync(command,
                                                       new List <string> {
                            d.Key.Id
                        });                               //Unsure if Id or UniqueId should be used

                        Write.WriteConsole(ConsoleTypes.Hue, @"Restoring HUE Bulb " + d.Key.Name);
                        //Thread.Sleep(500);
                    }
                    catch (Exception ex)
                    {
                        Write.WriteConsole(ConsoleTypes.Hue,
                                           "An Error occurred while restoring HUE Bulb " + d.Key.Name + ". Error: " + ex.Message);
                    }
                }
            }
            else
            {
                Write.WriteConsole(ConsoleTypes.Hue, @"Unable to connect to HUE Hub.");
            }
        }
コード例 #6
0
        public void clientConnection()
        {
            if (ip != null)         //If the user has selected a hub.
            {
                if (client == null) //If the user has selected a hub but the connection hasnt been attempted yet then make one.
                {
                    client = new LocalHueClient(ip);
                }

                else if (client.CheckConnection().Result == false) //If the connection has been made already check to ensure the user is still connected.
                {
                    txtResults.BackColor = Color.Red;              //Show error.
                    txtResults.Show();
                    txtResults.Text = "Connection failed, please make sure you are connected to the internet and have pressed connect.";
                }
            }
            else //If their is no hubs available then display an error.
            {
                txtResults.BackColor = Color.Red;
                txtResults.Show();
                txtResults.Text = "No hubs found, please try again.";
            }
        }
コード例 #7
0
        /// <summary>
        /// When the OK button is pressed, try to connect a bridge. If there is a checked
        /// item in the listbox, use that. Otherwise use the first item.
        /// </summary>
        private async void buttonOK_Click(object sender, EventArgs e)
        {
            try
            {
                LocatedBridge bridge = null;

                if (checkedListBoxBridges.CheckedItems.Count > 0)
                {
                    bridge = checkedListBoxBridges.CheckedItems[0] as LocatedBridge;
                }
                else if (checkedListBoxBridges.Items.Count > 0)
                {
                    bridge = checkedListBoxBridges.Items[0] as LocatedBridge;
                }

                if (bridge != null)
                {
                    client = new LocalHueClient(bridge.IpAddress);
                    client.Initialize(appKey);
                    if (!await client.CheckConnection())
                    {
                        MessageBox.Show("Could not connect client. This might be caused by an invalid application key.\n\n" +
                                        "Other parts of the application will not work.",
                                        "Error",
                                        MessageBoxButtons.OK,
                                        MessageBoxIcon.Error);
                        client = null;
                    }
                    this.Close();
                }
                else
                {
                    if (MessageBox.Show("No client connected. Other parts of the application will not work. Continue?",
                                        "Warning",
                                        MessageBoxButtons.YesNo,
                                        MessageBoxIcon.Warning) == DialogResult.Yes)
                    {
                        this.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(String.Format("Something went wrong while connecting. The error was '{0}'.",
                                              ex.Message),
                                "Error",
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
            }
        }
コード例 #8
0
        public void Connect(Action callbackMethod)
        {
            Task connectionTask;

            deviceName  = (String.IsNullOrWhiteSpace(deviceName) ? "iOS_" + CCRandom.GetRandomInt(0, 100) : deviceName);
            isCompleted = false;
            isConnected = false;

            connectionTask = new Task(async() =>
            {
                int locatorTimeout           = bridgeLocatorTimeout;
                Exception currentException   = new Exception();
                IBridgeLocator bridgeLocator = new HttpBridgeLocator();
                IEnumerable <LocatedBridge> locatedBridges = new List <LocatedBridge>();

                try
                {
                    locatedBridges = await bridgeLocator.LocateBridgesAsync(TimeSpan.FromSeconds(locatorTimeout));

                    if (((List <LocatedBridge>)locatedBridges).Count > 0)
                    {
                        while (((currentException.Source == null) ||
                                (currentException.Message == "Link button not pressed")) &&
                               (locatorTimeout >= 0))
                        {
                            try
                            {
                                hueClient = new LocalHueClient(((List <LocatedBridge>)locatedBridges)[0].IpAddress);

                                if (hueClient != null)
                                {
                                    if (await hueClient.CheckConnection() == false)
                                    {
                                        if (String.IsNullOrWhiteSpace(hueAppKey) == true)
                                        {
                                            hueAppKey = await hueClient.RegisterAsync(appName, deviceName);
                                        }

                                        if (String.IsNullOrWhiteSpace(hueAppKey) == false)
                                        {
                                            hueClient.Initialize(hueAppKey);

                                            colorBulbs = ((List <Light>) await hueClient.GetLightsAsync());

                                            for (int i = 0; i < colorBulbs.Count; i++)
                                            {
                                                if (colorBulbs[i].Type != "Extended color light")
                                                {
                                                    colorBulbs.RemoveAt(i);

                                                    i--;
                                                }
                                            }

                                            isConnected = true;

                                            break;
                                        }
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                            }
                            catch (Exception connectionException)
                            {
                                currentException = connectionException;
                            }

                            await Task.Delay(1000);

                            locatorTimeout--;
                        }
                    }
                }
                catch (Exception bridgeLocatorException)
                {
                    currentException = bridgeLocatorException;
                }

                isCompleted = true;

                callbackMethod();
            });

            connectionTask.Start();
        }
コード例 #9
0
        public async Task CheckConnectionTest()
        {
            var result = await _client.CheckConnection();

            Assert.IsTrue(result);
        }