private byte ChangeBrightness(int value) { var currentGroup = GroupDictionary[CurrentRoom.Value]; var currentBrightness = currentGroup.Action.Brightness; var delta = 5 * GetSign(value); var newBrightness = currentBrightness + (byte)delta; var command = new LightCommand { BrightnessIncrement = delta }; var currentState = OnOffStateForGroups[currentGroup]; if (!currentState) { command.On = true; } if (newBrightness <= 0) { command.On = false; } HueClient.SendGroupCommandAsync(command, currentGroup.Id); return((byte)newBrightness); }
public void Stop() { _hue = null; // this stop's UpdateLight from sending any more commands // but still continues to record the last/current color so it can be // sent when it's turned back on again }
/// <summary> /// /// </summary> /// <param name="client"></param> /// <param name="lightsToScan"></param> /// <param name="colorTemperature"></param> /// <param name="transitiontime"></param> private async Task ModifyFluxLights( HueClient hueClient, IEnumerable <Light> lights, Primitives.ColorTemperature newColorTemperature, Primitives.Brightness newBrightness) { lights = lights.Where(light => light.State.On && light.IsFluxControlled()); Dictionary <LightCommand, IList <string> > lightGroups = CalculateLightCommands(lights, newColorTemperature, newBrightness); // Send the light update command foreach (KeyValuePair <LightCommand, IList <string> > lightGroup in lightGroups) { try { HueResults result = await hueClient.SendCommandAsync(lightGroup.Key, lightGroup.Value); IEnumerable <string> lightNames = lightGroup.Value .Select(lightId => lights.Single(light => light.Id.Equals(lightId, StringComparison.OrdinalIgnoreCase)).Name) ?.Take(4); Log.Info($"'{nameof(ModifyFluxLights)}' set '{lightGroup.Value.Count()}' lights to color temperature {(lightGroup.Key.ColorTemperature.HasValue ? $"'{lightGroup.Key.ColorTemperature}'" : "'null'")} and brightness {(lightGroup.Key.Brightness.HasValue ? $"'{lightGroup.Key.Brightness}'" : "'null'")} for lights '{string.Join(", ", lightNames)}', IDs '{string.Join(", ", lightGroup.Value)}'."); } catch (Exception exception) { Log.Error($"Exception: '{nameof(ModifyFluxLights)}' exception for '{string.Join(", ", lightGroup.Value)}'. {exception.Message}"); } } }
private async void SendGroupCommand(int delay = 0) { lastCommand = DateTime.Now; await Task.Delay(delay); if (delay == 0 || DateTime.Now - lastCommand >= new TimeSpan(0, 0, 0, 0, delay)) { IsLoading = true; var appliance = Appliances.FirstOrDefault() as Light; if (appliance != null) { try { var client = new HueClient(appliance.HueUser); await client.SendCommandAsync(HueGroup); } catch (Exception ex) { DebugHelper.Debugger.WriteErrorLog("Error occurred while sending group command.", ex); await new MessageDialog("Error occurred while sending group command: " + ex.Message).ShowAsync(); } } IsLoading = false; } }
public async Task CheckConnectionWrongKeyTest() { IHueClient client = new HueClient(ConfigurationManager.AppSettings["ip"].ToString(), "wrongkey123"); var result = await client.CheckConnection(); Assert.IsFalse(result); }
public async Task CheckConnectionWrongIpTest() { IHueClient client = new HueClient("42.1.1.1", ConfigurationManager.AppSettings["key"].ToString()); var result = await client.CheckConnection(); Assert.IsFalse(result); }
private async Task UpdateSaturation(int sat, IReadOnlyCollection <string> lightIds) { _logger.LogDebug("Setting saturation to {sat} for light(s) {lights}...", sat, string.Join(',', lightIds)); var command = new LightCommand { Saturation = sat }; await HueClient.SendCommandAsync(command, lightIds); }
protected TestBase(ITestOutputHelper outputHelper) { var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(new XunitLoggerProvider(outputHelper)); _client = new HueClient(loggerFactory, DEV_USER, DEV_ADDRESS); _logger = loggerFactory.CreateLogger(GetType().Name); }
private async Task SetColorRed(IReadOnlyCollection <string> lightIds) { _logger.LogDebug("Setting color to red for light(s) {lights}...", string.Join(',', lightIds)); // "xy":[0.675,0.322]is red. var command = new LightCommand { ColorCoordinates = new[] { 0.675, 0.322 } }; await HueClient.SendCommandAsync(command, lightIds); }
public HueLightingSystem(string name, string ip) { //var bridges = GetBridges(); _client = new HueClient(ip); _client.RegisterAsync("ubilight", "ubilightkey"); _client.Initialize("ubilightkey"); Name = name; }
public override void OnExecute() { Hue = Context.CredentialProvider.Get <HueCredential, LocalHueClient>(); var lights = Hue.GetLightsAsync().Result; foreach (var light in lights) { Console.WriteLine(light.Id); } }
private async void LocateBridgeAction() { var result = await LocateBridgeDataLoader.LoadAsync(() => httpLocator.LocateBridgesAsync(TimeSpan.FromSeconds(5))); HttpBridges = string.Join(", ", result.ToArray()); if (result.Count() > 0) { _hueClient = new HueClient(result.First()); } }
private bool SwitchGroupOnOff() { var currentGroup = GroupDictionary[CurrentRoom.Value]; var currentState = OnOffStateForGroups[currentGroup]; var newState = !currentState; var command = new LightCommand { On = newState }; HueClient.SendGroupCommandAsync(command, currentGroup.Id); return(newState); }
//private BridgeInfo _hueBridge; public ReleaseNight() { InitializeComponent(); _navigationHelper = new NavigationHelper(this); _navigationHelper.LoadState += NavigationHelperOnLoadState; _navigationHelper.SaveState += (sender, args) => { MediaSimple.MediaPlayer.Pause(); }; //Task.Run(() => this.GetHueInfo()).Wait(); //_hueClient = new LocalHueClient(_hueBridge.internalipaddress); //_hueClient.Initialize(""); _hueClient = new LocalHueClient("10.10.10.193"); _hueClient.Initialize("CqnjoQvPHKdy1IkFVJggaTdflgWBF1HWQTOZYf2p"); }
private async void SendCommand() { lastCommand = DateTime.Now; await Task.Delay(1000); if (DateTime.Now - lastCommand >= new TimeSpan(0, 0, 1)) { IsLoading = true; var client = new HueClient(Light.HueUser); await client.SendCommandAsync(Light.HueLight); IsLoading = false; } }
private async Task RestoreOriginalValues(IEnumerable <Light> colorLights, IEnumerable <Light> ambianceLights) { var colorTasks = colorLights.Select(light => HueClient.SendCommandAsync(new LightCommand { On = light.State.On, ColorCoordinates = light.State.ColorCoordinates, Hue = light.State.Hue }, new[] { light.Id })); var ambianceTasks = ambianceLights.Select(light => HueClient.SendCommandAsync(new LightCommand { On = light.State.On, ColorTemperature = light.State.ColorTemperature }, new[] { light.Id })); var tasks = Enumerable.Union(colorTasks, ambianceTasks).ToList(); await Task.WhenAll(tasks); }
private async void SendCommand(RGBColor?color = null) { lastCommand = DateTime.Now; await Task.Delay(1000); if (DateTime.Now - lastCommand >= new TimeSpan(0, 0, 1)) { IsLoading = true; var client = new HueClient(Light.HueUser); Light.HueLight = await client.SendCommandAsync(Light.HueLight, color); IsLoading = false; RaisePropertyChanged("Light"); RaisePropertyChanged("ColorBrush"); } }
private async void SsdpLocateBridgeAction() { var result = await SsdpLocateBridgeDataLoader.LoadAsync(() => ssdpLocator.LocateBridgesAsync(TimeSpan.FromSeconds(5))); if (result == null) { result = new List <string>(); } SsdpBridges = string.Join(", ", result.ToArray()); if (result.Count() > 0) { _hueClient = new HueClient(result.First()); } }
public void SetBridge(string bridgeIP, string appKey, bool alreadyRegistered) { _hue = new HueClient(bridgeIP); if (alreadyRegistered) { _hue.Initialize(appKey); } else { var retryCount = 0; var regOk = false; while (!regOk || retryCount >= RETRY_MAX) { var reg = _hue.RegisterAsync(APP_NAME, appKey); reg.Wait(); if (!reg.Result) { ShowWarning("Please press the button on the bridge to register the application", 30); } else { regOk = true; } retryCount++; if (!regOk && retryCount < RETRY_MAX) { Thread.Sleep(RETRY_DELAY); } } if (!regOk) { ShowError("Failed to register application with bridge", 30); } } var lights = _hue.GetLightsAsync(); lights.Wait(); var choices = lights.Result.Select(x => new Tuple <string, string>(x.Id, string.Format("{0} ({1})", x.Name, x.Type))).ToList(); UpdateLightChoice(choices); }
public override void OnExecute() { Hue = Context.CredentialProvider.Get <HueCredential, LocalHueClient>(); var cmd = new LightCommand(); cmd.TurnOn(); var result = Hue.SendCommandAsync( cmd, new string[] { LightId }).Result; if (result.HasErrors()) { throw new InvalidOperationException(""); } }
public HueBuildLight(string ip, IEnumerable <string> lights, string intensity) { _hueClient = new HueClient(ip); _hueClient.Initialize(AppKey); _lights = lights.ToList(); int parsedInt; if (int.TryParse(intensity, out parsedInt)) { _intensity = parsedInt; } else { _intensity = MAX_INTENSITY; } }
public override int Run(string[] remainingArguments) { var hueClient = new HueClient(_ip); var result = hueClient.RegisterAsync(HueBuildLight.AppName, HueBuildLight.AppKey).Result; if (result) { Console.WriteLine("Registered correctly."); return(0); } //If we failed to register, attempt to initialise and see if we succeed as we may already be registered. hueClient.Initialize(HueBuildLight.AppKey); var initialised = hueClient.IsInitialized; Console.WriteLine(initialised ? "Already registered." : "Failed to register"); return(initialised ? 0 : 1); }
//private BridgeInfo _hueBridge; public RedAlert() { InitializeComponent(); _navigationHelper = new NavigationHelper(this); _navigationHelper.LoadState += NavigationHelperOnLoadState; _navigationHelper.SaveState += (sender, args) => { MediaSimple.MediaPlayer.Pause(); }; //Task.Run(() => this.GetHueInfo()).Wait(); //_hueClient = new LocalHueClient(_hueBridge.internalipaddress); //_hueClient.Initialize(""); //TODO: Complete Hue bridge self discovery //Until then I utilized the instructions at https://developers.meethue.com/documentation/getting-started // to hard code my info gathered from my router. _hueClient = new LocalHueClient("10.10.10.193"); _hueClient.Initialize("CqnjoQvPHKdy1IkFVJggaTdflgWBF1HWQTOZYf2p"); }
/// <summary> /// Called when the package is started. /// </summary> public override void OnStart() { PackageHost.WriteInfo("Connecting to " + PackageHost.GetSettingValue <string>("BridgeAddress")); hueClient = new HueClient(PackageHost.GetSettingValue <string>("BridgeAddress")); hueClient.Initialize(PackageHost.GetSettingValue <string>("BridgeUsername")); PackageHost.WriteInfo("Getting configuration"); var bridge = hueClient.GetBridgeAsync().GetAwaiter().GetResult(); PackageHost.PushStateObject <BridgeConfig>("BridgeConfig", bridge.Config); foreach (Light light in bridge.Lights) { PackageHost.PushStateObject <Light>(light.Name, light); } PackageHost.WriteInfo("Starting query process"); Task.Factory.StartNew(() => { int pause = 1000; while (PackageHost.IsRunning) { try { var lights = hueClient.GetLightsAsync().GetAwaiter().GetResult(); foreach (Light light in lights) { PackageHost.PushStateObject <Light>(light.Name, light); } pause = 1000; } catch (Exception ex) { if (pause < 60000) { pause *= 2; } PackageHost.WriteError("Error to query lights : {0}", ex.ToString()); } Thread.Sleep(pause); } }); PackageHost.WriteInfo("Connected to {0}", hueClient.ApiBase); }
private async Task SetupHue() { await SetupHueClient(); var groups = await HueClient.GetGroupsAsync(); FillGroupDictionary(groups); OnOffStateForGroups = groups.ToDictionary(group => group, group => group.State.AnyOn == true); Rooms = new LinkedList <RoomClass>(GroupDictionary.Keys); CurrentRoom = Rooms.Find(RoomClass.LivingRoom); if (CurrentRoom == null) { CurrentRoom = Rooms.First; } IsInitialized = true; }
//private BridgeInfo _hueBridge; public Imperial() { InitializeComponent(); _navigationHelper = new NavigationHelper(this); _navigationHelper.LoadState += NavigationHelperOnLoadState; //_navigationHelper.SaveState += (sender, args) => { MediaSimple.MediaPlayer.Pause(); }; //Task.Run(() => this.GetHueInfo()).Wait(); //_hueClient = new LocalHueClient(_hueBridge.internalipaddress); //_hueClient.Initialize(""); BitmapImage bitmapImage = new BitmapImage(); // Call BaseUri on the root Page element and combine it with a relative path // to consruct an absolute URI. bitmapImage.UriSource = new Uri(BaseUri, "/Assets/vadar2.jpg"); IMImage.Source = bitmapImage; _hueClient = new LocalHueClient("10.10.10.193"); _hueClient.Initialize("CqnjoQvPHKdy1IkFVJggaTdflgWBF1HWQTOZYf2p"); }
private async void SendSceneCommand() { if (SelectedHueScene != null) { IsLoading = true; var appliance = Appliances.FirstOrDefault() as Light; if (appliance != null && SelectedHueScene != null) { try { var client = new HueClient(appliance.HueUser); await client.SendCommandAsync(SelectedHueScene); HueGroup = await client.GetHueGroupByIdAsync(HueGroup.Id); } catch (Exception ex) { DebugHelper.Debugger.WriteErrorLog("Error occurred while sending scene command.", ex); await new MessageDialog("Error occurred while sending scene command: " + ex.Message).ShowAsync(); } } IsLoading = false; } }
private async void SsdpLocateBridgeAction() { var result = await SsdpLocateBridgeDataLoader.LoadAsync(() => ssdpLocator.LocateBridgesAsync(TimeSpan.FromSeconds(5))); SsdpBridges = string.Join(", ", result.ToArray()); if (result.Count() > 0) _hueClient = new HueClient(result.First()); }
internal void ManualRegister(string ip) { _hueClient = new HueClient(ip); }
public static async Task RunLightControl(Configuration configuration, HueClient hueClient) { var timeBetweenChecks = new TimeSpan(Math.Max(configuration.TransitionTime.Ticks, configuration.PollingFrequency.Ticks)); await AsyncUtils.ContinuallyExecuteReportingExceptionsOnlyOnce(async() => { var dmxUniverse = configuration.DMXConfiguration.Universe; RunningState runningState = RunningState.HueShift; using (var controller = new ArtNetController()) { controller.Address = IPAddress.Parse(configuration.DMXConfiguration.ListeningIPAddress); var groups = await hueClient.GetGroupsAsync(); var dmxControlGroupName = "DmxControlGroup"; foreach (var item in groups) { if (item.Name == dmxControlGroupName) { await hueClient.DeleteGroupAsync(item.Id); Console.WriteLine("Deleting existing control group: " + item.Id); } } // var groupId = await hueClient.CreateGroupAsync( // configuration.DMXConfiguration.LightIdsInDmxGroup.Select(x => x.ToString()).ToList(), // dmxControlGroupName, // null, // Q42.HueApi.Models.Groups.GroupType.LightGroup); var stateQueue = new ConcurrentQueue <LightState>(); var startingChannel = configuration.DMXConfiguration.StartingChannel; controller.DmxPacketReceived += (sender, packet) => { if (packet.SubUniverse != dmxUniverse) { return; } LightState state = new LightState( packet.Data[startingChannel] > 0, packet.Data[startingChannel + 1], packet.Data[startingChannel + 2]); if (state.IsOn) { //Sanity check to prevent runawayqueu const int maxQueueSize = 10000; if (stateQueue.Count < maxQueueSize) { stateQueue.Enqueue(state); } } else { //Console.Write("D"); } }; controller.Start(); var lastApiSentTime = DateTimeOffset.MinValue; var lastTimeDmxPacketDetected = DateTimeOffset.MinValue; // LightState lastSentLightState = new LightState(); Console.WriteLine("_------------------STARTING "); var controlState = new Dictionary <string, LightControlStatus>(); var sunriseSunsetState = new AppState(); while (true) { switch (runningState) { case RunningState.HueShift: var currentTime = DateTimeOffset.Now; int colorTemperature = GetTargetColorTemperature(currentTime, configuration); await PerformDayNightCycling(hueClient, colorTemperature, currentTime, sunriseSunsetState, configuration); var timeStartedWaiting = DateTimeOffset.Now; do { if (!stateQueue.IsEmpty) { lastTimeDmxPacketDetected = DateTimeOffset.Now; runningState = RunningState.DMX; Console.WriteLine("DMX Mode detected"); break; } else { Thread.Sleep(configuration.DMXConfiguration.MillisToSleepBetweenQueueChecks); //await Task.Delay(.0).ConfigureAwait(false); } } while ((DateTimeOffset.Now - timeStartedWaiting) < timeBetweenChecks); break; default: break; // case RunningState.DMX: // var transitionDuration = configuration.DMXConfiguration.TransitionTime; // var minWaitDurationBetweenApiCalls = configuration.DMXConfiguration.MinWaitDurationBetweenApiCalls; // var timeSinceLastSend = DateTimeOffset.Now - lastApiSentTime; // var timeSinceLastReceivedDMXPacket = DateTimeOffset.Now - lastTimeDmxPacketDetected; // LightState mostCurrentLightState = new LightState(); // bool haveReceivedNextDMXPacket = false; // while (timeSinceLastSend < minWaitDurationBetweenApiCalls) // { // Thread.Sleep(configuration.DMXConfiguration.MillisToSleepBetweenQueueChecks); // LightState latestLightState; // while (stateQueue.TryDequeue(out latestLightState)) // { // mostCurrentLightState = latestLightState; // haveReceivedNextDMXPacket = true; // lastTimeDmxPacketDetected = DateTime.Now; // } // timeSinceLastSend = DateTimeOffset.Now - lastApiSentTime; // } // if (!haveReceivedNextDMXPacket) // { // LightState latestLightState; // while (!stateQueue.TryDequeue(out latestLightState)) // { // Thread.Sleep(configuration.DMXConfiguration.MillisToSleepBetweenQueueChecks); // if ((DateTimeOffset.Now - lastTimeDmxPacketDetected) > configuration.DMXConfiguration.TimeAfterLastDmxPacketToReturnToShifting) // { // runningState = RunningState.HueShift; // break; // } // } // mostCurrentLightState = latestLightState; // haveReceivedNextDMXPacket = true; // lastTimeDmxPacketDetected = DateTime.Now; // } // if (runningState == RunningState.DMX) // { // if (!mostCurrentLightState.Equals(lastSentLightState)) // { // Console.WriteLine(); // var command = new LightCommand(); // if (mostCurrentLightState.Brightness != lastSentLightState.Brightness) // command.Brightness = mostCurrentLightState.Brightness; // //if (latest.ColorTemperature != last.ColorTemperature) // // command.ColorTemperature = (int)map(latest.ColorTemperature, 0, 255, (float)ColorTemperature.Blue, (float)ColorTemperature.Red); // command.TransitionTime = transitionDuration; // Console.Write($"Setting: {mostCurrentLightState.IsOn} {mostCurrentLightState.Brightness} {mostCurrentLightState.ColorTemperature}"); // var hueResults = await hueClient.SendGroupCommandAsync(command, groupId); // foreach (var error in hueResults.Errors) // { // Console.WriteLine($"Error: {error}"); // } // lastApiSentTime = DateTimeOffset.Now; // lastSentLightState = mostCurrentLightState; // } // } // break; } } } }); }
private static async Task PerformDayNightCycling(HueClient hueClient, int colorTemperature, DateTimeOffset currentTime, AppState appState, Configuration configuration) { var allLights = await hueClient.GetLightsAsync(); var lights = allLights.ToList(); var idToLights = allLights.ToDictionary(x => x.Id, x => x); var nameToLights = allLights.ToDictionary(x => x.Name, x => x); var namesOfLightsToExclude = configuration.NamesOfLightsToExclude.ToHashSet(); var lightsAvailableToChange = allLights.Where(x => x.State.On && x.State.ColorTemperature != colorTemperature && !namesOfLightsToExclude.Contains(x.Name)); var lightsToChange = new List <Light>(); foreach (var light in lights) { if (!appState.Lights.TryGetValue(light.Id, out var state)) { state = appState.Lights[light.Id] = new LightControlStatus(DateTimeOffset.MinValue, currentTime, DateTimeOffset.MinValue, DateTimeOffset.MinValue, TimeSpan.Zero, LightControlState.Off, light); } } var sunriseAndSunset = GetSunriseAndSunset(currentTime, configuration); var shouldDoSlowTransitionAtSunriseOrSunset = (appState.LastRunTime <sunriseAndSunset.sunrise && currentTime> sunriseAndSunset.sunrise) || (appState.LastRunTime <sunriseAndSunset.sunset && currentTime> sunriseAndSunset.sunset); var transitionTimeForBatch = configuration.TransitionTime; if (shouldDoSlowTransitionAtSunriseOrSunset) { Console.WriteLine($"{DateTime.Now}: all lights -> { colorTemperature }. sunrise: {sunriseAndSunset.sunrise} sunset: {sunriseAndSunset.sunrise}"); Console.WriteLine(); transitionTimeForBatch = configuration.TransitionTimeAtSunriseAndSunset; foreach (var light in lights) { var state = appState.Lights[light.Id]; if (!light.State.On) { state.LightControlState = LightControlState.Off; state.HueShiftTookControlTime = DateTimeOffset.MinValue; state.TransitionRequestedTime = DateTimeOffset.MinValue; state.RequestedTransitionDuration = TimeSpan.Zero; state.DetectedOnTime = DateTimeOffset.MinValue; } else { lightsToChange.Add(light); state.LightControlState = LightControlState.Transitioning; state.HueShiftTookControlTime = currentTime; state.TransitionRequestedTime = currentTime; state.RequestedTransitionDuration = configuration.TransitionTimeAtSunriseAndSunset; state.DetectedOnTime = currentTime; } } } else { foreach (var light in lights) { var state = appState.Lights[light.Id]; if (!light.State.On) { state.LightControlState = LightControlState.Off; state.HueShiftTookControlTime = DateTimeOffset.MinValue; state.TransitionRequestedTime = DateTimeOffset.MinValue; state.RequestedTransitionDuration = TimeSpan.Zero; state.DetectedOnTime = DateTimeOffset.MinValue; } else { switch (state.LightControlState) { case LightControlState.Off: lightsToChange.Add(light); state.LightControlState = LightControlState.Transitioning; state.HueShiftTookControlTime = currentTime; state.TransitionRequestedTime = currentTime; state.RequestedTransitionDuration = configuration.TransitionTime; state.DetectedOnTime = currentTime; break; case LightControlState.Transitioning: TimeSpan transitionTimeElapsed = currentTime - state.TransitionRequestedTime; var allowedTolerance = TimeSpan.FromSeconds(10); bool hasTransitionTimeElapsed = transitionTimeElapsed > (state.RequestedTransitionDuration + allowedTolerance); if ((light.State.ColorTemperature == colorTemperature) || hasTransitionTimeElapsed) { state.LightControlState = LightControlState.HueShiftAutomated; state.TransitionRequestedTime = DateTimeOffset.MinValue; state.RequestedTransitionDuration = TimeSpan.Zero; } break; case LightControlState.HueShiftAutomated: if (light.State.ColorTemperature != colorTemperature) { state.LightControlState = LightControlState.ManualControl; } break; case LightControlState.ManualControl: break; } } } } appState.LastRunTime = currentTime; foreach (var onLight in lightsToChange) { Console.WriteLine($"{DateTime.Now}: Light { onLight.Name } switching { onLight.State.ColorTemperature } -> { colorTemperature }"); } if (lightsToChange.Count > 0) { var command = new LightCommand(); command.ColorTemperature = colorTemperature; command.TransitionTime = transitionTimeForBatch; await hueClient.SendCommandAsync(command, lightsToChange.Select(x => x.Id).ToList()); } }
static Task <HttpResponseMessage> StreamAsync(HueClient hueClient, CancellationToken cancellationToken = default) => hueClient.StreamEventAsync(cancellationToken);