WLED/wled00/hue.cpp

209 lines
4.9 KiB
C++
Raw Normal View History

#include "wled.h"
/*
* Sync to Philips hue lights
*/
#ifndef WLED_DISABLE_HUESYNC
void handleHue()
{
2019-02-18 22:34:21 +01:00
if (hueReceived)
{
colorUpdated(CALL_MODE_HUE); hueReceived = false;
2019-02-18 22:34:21 +01:00
if (hueStoreAllowed && hueNewKey)
{
2020-11-06 22:12:48 +01:00
serializeConfigSec(); //save api key
2019-02-18 22:34:21 +01:00
hueStoreAllowed = false;
hueNewKey = false;
}
}
2019-10-18 14:06:07 +02:00
if (!WLED_CONNECTED || hueClient == nullptr || millis() - hueLastRequestSent < huePollIntervalMs) return;
hueLastRequestSent = millis();
if (huePollingEnabled)
{
reconnectHue();
} else {
hueClient->close();
if (hueError == HUE_ERROR_ACTIVE) hueError = HUE_ERROR_INACTIVE;
2019-10-18 14:06:07 +02:00
}
}
2019-02-18 22:34:21 +01:00
void reconnectHue()
{
2019-10-18 13:26:39 +02:00
if (!WLED_CONNECTED || !huePollingEnabled) return;
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Hue reconnect"));
2019-02-18 22:34:21 +01:00
if (hueClient == nullptr) {
hueClient = new AsyncClient();
hueClient->onConnect(&onHueConnect, hueClient);
hueClient->onData(&onHueData, hueClient);
hueClient->onError(&onHueError, hueClient);
hueAuthRequired = (strlen(hueApiKey)<20);
}
2019-02-18 22:34:21 +01:00
hueClient->connect(hueIP, 80);
}
void onHueError(void* arg, AsyncClient* client, int8_t error)
{
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Hue err"));
hueError = HUE_ERROR_TIMEOUT;
2019-02-18 22:34:21 +01:00
}
void onHueConnect(void* arg, AsyncClient* client)
{
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Hue connect"));
2019-02-18 22:34:21 +01:00
sendHuePoll();
}
void sendHuePoll()
{
if (hueClient == nullptr || !hueClient->connected()) return;
String req = "";
if (hueAuthRequired)
{
req += F("POST /api HTTP/1.1\r\nHost: ");
2019-02-18 22:34:21 +01:00
req += hueIP.toString();
req += F("\r\nContent-Length: 25\r\n\r\n{\"devicetype\":\"wled#esp\"}");
2019-02-18 22:34:21 +01:00
} else
{
2020-09-20 01:18:31 +02:00
req += F("GET /api/");
2019-02-18 22:34:21 +01:00
req += hueApiKey;
2020-09-20 01:18:31 +02:00
req += F("/lights/");
req += String(huePollLightId);
req += F(" HTTP/1.1\r\nHost: ");
2019-02-18 22:34:21 +01:00
req += hueIP.toString();
req += "\r\n\r\n";
}
2019-02-18 22:34:21 +01:00
hueClient->add(req.c_str(), req.length());
hueClient->send();
hueLastRequestSent = millis();
}
void onHueData(void* arg, AsyncClient* client, void *data, size_t len)
{
if (!len) return;
char* str = (char*)data;
DEBUG_PRINTLN(hueApiKey);
DEBUG_PRINTLN(str);
//only get response body
str = strstr(str,"\r\n\r\n");
if (str == nullptr) return;
str += 4;
StaticJsonDocument<1024> root;
if (str[0] == '[') //is JSON array
{
auto error = deserializeJson(root, str);
if (error)
{
hueError = HUE_ERROR_JSON_PARSING; return;
}
int hueErrorCode = root[0][F("error")]["type"];
if (hueErrorCode)//hue bridge returned error
{
hueError = hueErrorCode;
switch (hueErrorCode)
{
case 1: hueAuthRequired = true; break; //Unauthorized user
case 3: huePollingEnabled = false; break; //Invalid light ID
case 101: hueAuthRequired = true; break; //link button not presset
}
return;
}
if (hueAuthRequired)
{
2020-09-20 01:18:31 +02:00
const char* apikey = root[0][F("success")][F("username")];
2019-03-05 10:59:15 +01:00
if (apikey != nullptr && strlen(apikey) < sizeof(hueApiKey))
{
2021-09-11 01:17:42 +02:00
strlcpy(hueApiKey, apikey, sizeof(hueApiKey));
hueAuthRequired = false;
hueNewKey = true;
}
}
2019-02-18 22:34:21 +01:00
return;
}
2019-02-18 22:34:21 +01:00
//else, assume it is JSON object, look for state and only parse that
str = strstr(str,"state");
if (str == nullptr) return;
str = strstr(str,"{");
auto error = deserializeJson(root, str);
if (error)
{
hueError = HUE_ERROR_JSON_PARSING; return;
}
float hueX=0, hueY=0;
uint16_t hueHue=0, hueCt=0;
byte hueBri=0, hueSat=0, hueColormode=0;
if (root["on"]) {
if (root.containsKey("bri")) //Dimmable device
{
hueBri = root["bri"];
hueBri++;
2020-09-20 01:18:31 +02:00
const char* cm =root[F("colormode")];
if (cm != nullptr) //Color device
{
2020-09-20 01:18:31 +02:00
if (strstr(cm,("ct")) != nullptr) //ct mode
{
hueCt = root["ct"];
hueColormode = 3;
} else if (strstr(cm,"xy") != nullptr) //xy mode
{
hueX = root["xy"][0]; // 0.5051
hueY = root["xy"][1]; // 0.4151
hueColormode = 1;
} else //hs mode
{
2021-07-01 20:51:52 +02:00
hueHue = root["hue"];
2020-09-20 01:18:31 +02:00
hueSat = root[F("sat")];
hueColormode = 2;
}
}
} else //On/Off device
{
hueBri = briLast;
}
} else
{
hueBri = 0;
}
hueError = HUE_ERROR_ACTIVE;
//apply vals
if (hueBri != hueBriLast)
{
if (hueApplyOnOff)
{
if (hueBri==0) {bri = 0;}
else if (bri==0 && hueBri>0) bri = briLast;
}
if (hueApplyBri)
{
if (hueBri>0) bri = hueBri;
}
hueBriLast = hueBri;
}
if (hueApplyColor)
{
switch(hueColormode)
{
case 1: if (hueX != hueXLast || hueY != hueYLast) colorXYtoRGB(hueX,hueY,col); hueXLast = hueX; hueYLast = hueY; break;
case 2: if (hueHue != hueHueLast || hueSat != hueSatLast) colorHStoRGB(hueHue,hueSat,col); hueHueLast = hueHue; hueSatLast = hueSat; break;
case 3: if (hueCt != hueCtLast) colorCTtoRGB(hueCt,col); hueCtLast = hueCt; break;
}
}
2019-02-18 22:34:21 +01:00
hueReceived = true;
}
#else
void handleHue(){}
void reconnectHue(){}
#endif