Tasmota/tasmota/xdrv_52_3_berry_light_state...

228 lines
5.6 KiB
C++

/*
xdrv_52_3_berry_light_state.ino - Berry scripting language, native fucnctions
Copyright (C) 2021 Stephan Hadinger, Berry language by Guan Wenliang https://github.com/Skiars/berry
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// Mappgin from internal light and a generic `light_state` Berry class
#ifdef USE_BERRY
#ifdef USE_LIGHT
#include "berry.h"
void* ls_init(int32_t type) {
if (type < 0 || type > LST_MAX) { return NULL; } // fail
LightStateClass * l = new LightStateClass();
l->setSubType(type);
if (type == 2) { l->setColorMode(LCM_CT); }
return (LightStateClass*)l;
}
int32_t ls_r(class LightStateClass* l) {
uint8_t r;
l->getActualRGBCW(&r, NULL, NULL, NULL, NULL);
return r;
}
int32_t ls_g(class LightStateClass* l) {
uint8_t g;
l->getActualRGBCW(NULL, &g, NULL, NULL, NULL);
return g;
}
int32_t ls_b(class LightStateClass* l) {
uint8_t b;
l->getActualRGBCW(NULL, NULL, &b, NULL, NULL);
return b;
}
float ls_x(class LightStateClass* l) {
float x;
l->getXY(&x, NULL);
return x;
}
float ls_y(class LightStateClass* l) {
float y;
l->getXY(NULL, &y);
return y;
}
int32_t ls_hue(class LightStateClass* l) {
uint16_t hue;
l->getHSB(&hue, NULL, NULL);
return hue;
}
int32_t ls_hue16(class LightStateClass* l) {
return l->getHue16();
}
int32_t ls_sat(class LightStateClass* l) {
uint8_t sat;
l->getHSB(NULL, &sat, NULL);
return sat;
}
int32_t ls_bri(class LightStateClass* l) {
return l->getBri();
}
int32_t ls_type(class LightStateClass* l) {
return l->getSubType();
}
void ls_set_rgb(class LightStateClass* l, int32_t r, int32_t g, int32_t b) {
l->setRGB(r, g, b, false);
}
void ls_set_huesat(class LightStateClass* l, int32_t hue, int32_t sat) {
l->setHS(hue, sat);
}
void ls_set_hue16sat(class LightStateClass* l, int32_t hue16, int32_t sat) {
l->setH16S(hue16, sat);
}
void ls_set_bri(class LightStateClass* l, int32_t bri) {
l->setBri(bri);
}
int32_t ls_get_power(class LightStateClass* l) {
return l->getPower();
}
void ls_set_xy(class LightStateClass* l, float x, float y) {
uint8_t rr, gg, bb;
uint16_t hue;
uint8_t sat;
XyToRgb(x, y, &rr, &gg, &bb);
l->setRGB(rr, gg, bb, false);
}
void ls_set_power(class LightStateClass* l, int32_t pow) {
l->setPower(pow);
}
int32_t ls_reachable(class LightStateClass* l) {
return l->getReachable();
}
void ls_set_reachable(class LightStateClass* l, int32_t reachable) {
l->setReachable(reachable);
}
void ls_set_mode_rgb(class LightStateClass* l) {
l->setColorMode(LCM_RGB);
}
void ls_set_mode_ct(class LightStateClass* l) {
l->setColorMode(LCM_CT);
}
int32_t ls_mode_rgb(class LightStateClass* l) {
return (l->getColorMode() & LCM_RGB) ? 1 : 0;
}
int32_t ls_mode_ct(class LightStateClass* l) {
return (l->getColorMode() & LCM_CT) ? 1 : 0;
}
void ls_set_ct(class LightStateClass* l, int32_t ct) {
l->setCT(ct);
l->setColorMode(LCM_CT);
}
int32_t ls_ct(class LightStateClass* l) {
return l->getCT();
}
// Gamma functions
int32_t ls_gamma8(int32_t val) {
return ledGamma(val);
}
int32_t ls_gamma10(int32_t val) {
return ledGamma10_10(val);
}
int32_t ls_rev_gamma10(int32_t val) {
return ledGammaReverse(val);
}
// get returning a complete map, similar to `light.get()`
extern "C" int light_state_get(bvm *vm) {
be_getmember(vm, 1, "_p");
LightStateClass * l = (LightStateClass *) be_tocomptr(vm, -1);
be_newobject(vm, "map");
uint32_t sub_type = l->getSubType();
char s_rgb[8] = {0}; // RGB raw levels string
uint8_t r, g, b, cw, ww;
uint16_t hue;
uint8_t sat;
uint8_t briRGB, briCT;
l->getActualRGBCW(&r, &g, &b, &cw, &ww);
l->getHSB(&hue, &sat, &briRGB);
briCT = l->getBriCT();
bool mode_rgb = l->getColorMode() & LCM_RGB;
bool mode_ct = !mode_rgb;
// type
be_map_insert_int(vm, "type", sub_type);
// power
be_map_insert_bool(vm, "power", l->getPower());
// bri
if (sub_type > 0) {
be_map_insert_int(vm, "bri", l->getBri());
}
// color_mode
if (sub_type >= 3) {
be_map_insert_bool(vm, "mode_rgb", ls_mode_rgb(l));
}
if (sub_type >= 4 || sub_type == 2) {
be_map_insert_bool(vm, "mode_ct", ls_mode_ct(l));
}
// RGB
if (sub_type >= 3 && mode_rgb) {
snprintf(s_rgb, sizeof(s_rgb), PSTR("%02X%02X%02X"), r, g, b);
be_map_insert_str(vm, "rgb", s_rgb);
be_map_insert_int(vm, "hue", hue);
be_map_insert_int(vm, "sat", sat);
}
// CT when 2 white channels
if ((sub_type == 2 || sub_type == 5) && mode_ct) {
be_map_insert_int(vm, "ct", l->getCT());
}
if (sub_type > 0) {
uint8_t channels[LST_MAX] = {0};
switch (sub_type) {
case 1:
channels[0] = briRGB;
break;
case 2:
channels[0] = cw;
channels[1] = ww;
break;
case 3:
case 4:
case 5:
channels[0] = r;
channels[1] = g;
channels[2] = b;
channels[3] = cw;
channels[4] = ww;
break;
default:
break;
}
be_map_insert_list_uint8(vm, "channels", channels, sub_type);
}
be_pop(vm, 1);
be_return(vm);
}
#endif // USE_LIGHT
#endif // USE_BERRY