WLED/wled00/json.cpp

#include "wled.h"

/*
 * JSON API (De)serialization
 */

void deserializeSegment(JsonObject elem, byte it)
{
  byte id = elem[F("id")] | it;
  if (id < strip.getMaxSegments())
  {
    WS2812FX::Segment& seg = strip.getSegment(id);
    uint16_t start = elem[F("start")] | seg.start;
    int stop = elem[F("stop")] | -1;

    if (stop < 0) {
      uint16_t len = elem[F("len")];
      stop = (len > 0) ? start + len : seg.stop;
    }
    uint16_t grp = elem[F("grp")] | seg.grouping;
    uint16_t spc = elem[F("spc")] | seg.spacing;
    strip.setSegment(id, start, stop, grp, spc);

    int segbri = elem["bri"] | -1;
    if (segbri == 0) {
      seg.setOption(SEG_OPTION_ON, 0);
    } else if (segbri > 0) {
      seg.opacity = segbri;
      seg.setOption(SEG_OPTION_ON, 1);
    }
  
    seg.setOption(SEG_OPTION_ON, elem["on"] | seg.getOption(SEG_OPTION_ON));
    
    JsonArray colarr = elem[F("col")];
    if (!colarr.isNull())
    {
      for (uint8_t i = 0; i < 3; i++)
      {
        JsonArray colX = colarr[i];
        if (colX.isNull()) break;
        byte sz = colX.size();
        if (sz > 0 && sz < 5)
        {
          int rgbw[] = {0,0,0,0};
          byte cp = copyArray(colX, rgbw);
          
          if (cp == 1) {
            if (rgbw[0] == 0) seg.colors[i] = 0;
            else {
              byte ctrgb[] = {0,0,0,0};
              colorKtoRGB(rgbw[0], ctrgb);
              for (uint8_t c = 0; c < 3; c++) rgbw[c] = ctrgb[c];
            }
          }
          if (id == strip.getMainSegmentId() && i < 2) //temporary, to make transition work on main segment
          { 
            if (i == 0) {col[0] = rgbw[0]; col[1] = rgbw[1]; col[2] = rgbw[2]; col[3] = rgbw[3];}
            if (i == 1) {colSec[0] = rgbw[0]; colSec[1] = rgbw[1]; colSec[2] = rgbw[2]; colSec[3] = rgbw[3];}
          } else {
            seg.colors[i] = ((rgbw[3] << 24) | ((rgbw[0]&0xFF) << 16) | ((rgbw[1]&0xFF) << 8) | ((rgbw[2]&0xFF)));
          }
        }
      }
    }

    // lx parser
    #ifdef WLED_ENABLE_LOXONE
    int lx = elem[F("lx")] | -1;
    if (lx > 0) {
      parseLxJson(lx, id, false);
    }
    int ly = elem[F("ly")] | -1;
    if (ly > 0) {
      parseLxJson(ly, id, true);
    }
    #endif
    
    //if (pal != seg.palette && pal < strip.getPaletteCount()) strip.setPalette(pal);
    seg.setOption(SEG_OPTION_SELECTED, elem[F("sel")] | seg.getOption(SEG_OPTION_SELECTED));
    seg.setOption(SEG_OPTION_REVERSED, elem[F("rev")] | seg.getOption(SEG_OPTION_REVERSED));
    seg.setOption(SEG_OPTION_MIRROR  , elem[F("mi")]  | seg.getOption(SEG_OPTION_MIRROR  ));

    //temporary, strip object gets updated via colorUpdated()
    if (id == strip.getMainSegmentId()) {
      effectCurrent = elem[F("fx")] | effectCurrent;
      effectSpeed = elem[F("sx")] | effectSpeed;
      effectIntensity = elem[F("ix")] | effectIntensity;
      effectPalette = elem[F("pal")] | effectPalette;
    } else { //permanent
      byte fx = elem[F("fx")] | seg.mode;
      if (fx != seg.mode && fx < strip.getModeCount()) strip.setMode(id, fx);
      seg.speed = elem[F("sx")] | seg.speed;
      seg.intensity = elem[F("ix")] | seg.intensity;
      seg.palette = elem[F("pal")] | seg.palette;
    }

    JsonArray iarr = elem[F("i")]; //set individual LEDs
    if (!iarr.isNull()) {
      strip.setPixelSegment(id);

      //freeze and init to black
      if (!seg.getOption(SEG_OPTION_FREEZE)) {
        seg.setOption(SEG_OPTION_FREEZE, true);
        strip.fill(0);
      }

      uint16_t start = 0, stop = 0;
      byte set = 0; //0 nothing set, 1 start set, 2 range set

      for (uint16_t i = 0; i < iarr.size(); i++) {
        if(iarr[i].is<JsonInteger>()) {
          if (!set) {
            start = iarr[i];
            set = 1;
          } else {
            stop = iarr[i];
            set = 2;
          }
        } else {
          JsonArray icol = iarr[i];
          if (icol.isNull()) break;

          byte sz = icol.size();
          if (sz == 0 && sz > 4) break;

          int rgbw[] = {0,0,0,0};
          byte cp = copyArray(icol, rgbw);

          if (set < 2) stop = start + 1;
          for (uint16_t i = start; i < stop; i++) {
            strip.setPixelColor(i, rgbw[0], rgbw[1], rgbw[2], rgbw[3]);
          }
          if (!set) start++;
          set = 0;
        }
      }
      strip.setPixelSegment(255);
      strip.trigger();
    } else { //return to regular effect
      seg.setOption(SEG_OPTION_FREEZE, false);
    }

  }
}

bool deserializeState(JsonObject root)
{
  strip.applyToAllSelected = false;
  bool stateResponse = root[F("v")] | false;

  int ps = root[F("ps")] | -1;
  if (ps >= 0) applyPreset(ps);
  
  bri = root["bri"] | bri;
  
  bool on = root["on"] | (bri > 0);
  if (!on != !bri) toggleOnOff();

  int tr = root[F("transition")] | -1;
  if (tr >= 0)
  {
    transitionDelay = tr;
    transitionDelay *= 100;
  }

  tr = root[F("tt")] | -1;
  if (tr >= 0)
  {
    transitionDelayTemp = tr;
    transitionDelayTemp *= 100;
    jsonTransitionOnce = true;
  }
  
  int cy = root[F("pl")] | -2;
  if (cy > -2) presetCyclingEnabled = (cy >= 0);
  JsonObject ccnf = root[F("ccnf")];
  presetCycleMin = ccnf[F("min")] | presetCycleMin;
  presetCycleMax = ccnf[F("max")] | presetCycleMax;
  tr = ccnf[F("time")] | -1;
  if (tr >= 2) presetCycleTime = tr;

  JsonObject nl = root[F("nl")];
  nightlightActive    = nl["on"]   | nightlightActive;
  nightlightDelayMins = nl[F("dur")]  | nightlightDelayMins;
  nightlightMode      = nl[F("fade")] | nightlightMode; //deprecated
  nightlightMode      = nl[F("mode")] | nightlightMode;
  nightlightTargetBri = nl[F("tbri")] | nightlightTargetBri;

  JsonObject udpn = root[F("udpn")];
  notifyDirect         = udpn[F("send")] | notifyDirect;
  receiveNotifications = udpn[F("recv")] | receiveNotifications;
  bool noNotification  = udpn[F("nn")]; //send no notification just for this request

  int timein = root[F("time")] | -1;
  if (timein != -1) setTime(timein);
  doReboot = root[F("rb")] | doReboot;

  realtimeOverride = root[F("lor")] | realtimeOverride;
  if (realtimeOverride > 2) realtimeOverride = REALTIME_OVERRIDE_ALWAYS;

  byte prevMain = strip.getMainSegmentId();
  strip.mainSegment = root[F("mainseg")] | prevMain;
  if (strip.getMainSegmentId() != prevMain) setValuesFromMainSeg();

  int it = 0;
  JsonVariant segVar = root[F("seg")];
  if (segVar.is<JsonObject>())
  {
    int id = segVar[F("id")] | -1;
    
    if (id < 0) { //set all selected segments
      bool didSet = false;
      byte lowestActive = 99;
      for (byte s = 0; s < strip.getMaxSegments(); s++)
      {
        WS2812FX::Segment sg = strip.getSegment(s);
        if (sg.isActive())
        {
          if (lowestActive == 99) lowestActive = s;
          if (sg.isSelected()) {
            deserializeSegment(segVar, s);
            didSet = true;
          }
        }
      }
      if (!didSet && lowestActive < strip.getMaxSegments()) deserializeSegment(segVar, lowestActive);
    } else { //set only the segment with the specified ID
      deserializeSegment(segVar, it);
    }
  } else {
    JsonArray segs = segVar.as<JsonArray>();
    for (JsonObject elem : segs)
    {
      deserializeSegment(elem, it);
      it++;
    }
  }

  usermods.readFromJsonState(root);

  colorUpdated(noNotification ? NOTIFIER_CALL_MODE_NO_NOTIFY : NOTIFIER_CALL_MODE_DIRECT_CHANGE);

  //write presets to flash directly?
  bool persistSaves = !(root[F("np")] | false);

  ps = root[F("psave")] | -1;
  if (ps >= 0) savePreset(ps, persistSaves);

  return stateResponse;
}

void serializeSegment(JsonObject& root, WS2812FX::Segment& seg, byte id)
{
	root[F("id")] = id;
	root[F("start")] = seg.start;
	root[F("stop")] = seg.stop;
	root[F("len")] = seg.stop - seg.start;
  root[F("grp")] = seg.grouping;
  root[F("spc")] = seg.spacing;
  root["on"] = seg.getOption(SEG_OPTION_ON);
  byte segbri = seg.opacity;
  root["bri"] = (segbri) ? segbri : 255;

	JsonArray colarr = root.createNestedArray("col");
  
	for (uint8_t i = 0; i < 3; i++)
	{
		JsonArray colX = colarr.createNestedArray();
    if (id == strip.getMainSegmentId() && i < 2) //temporary, to make transition work on main segment
    {
      if (i == 0) {
        colX.add(col[0]); colX.add(col[1]); colX.add(col[2]); if (useRGBW) colX.add(col[3]); 
      } else {
         colX.add(colSec[0]); colX.add(colSec[1]); colX.add(colSec[2]); if (useRGBW) colX.add(colSec[3]); 
      }
    } else {
  		colX.add((seg.colors[i] >> 16) & 0xFF);
  		colX.add((seg.colors[i] >> 8) & 0xFF);
  		colX.add((seg.colors[i]) & 0xFF);
  		if (useRGBW)
  			colX.add((seg.colors[i] >> 24) & 0xFF);
    }
	}

	root[F("fx")]  = seg.mode;
	root[F("sx")]  = seg.speed;
	root[F("ix")]  = seg.intensity;
	root[F("pal")] = seg.palette;
	root[F("sel")] = seg.isSelected();
	root[F("rev")] = seg.getOption(SEG_OPTION_REVERSED);
  root[F("mi")]  = seg.getOption(SEG_OPTION_MIRROR);
}


void serializeState(JsonObject root)
{
  if (errorFlag) root[F("error")] = errorFlag;
  
  root["on"] = (bri > 0);
  root["bri"] = briLast;
  root[F("transition")] = transitionDelay/100; //in 100ms

  root[F("ps")] = currentPreset;
  root[F("pss")] = savedPresets;
  root[F("pl")] = (presetCyclingEnabled) ? 0: -1;

  usermods.addToJsonState(root);

  //temporary for preset cycle
  JsonObject ccnf = root.createNestedObject("ccnf");
  ccnf[F("min")] = presetCycleMin;
  ccnf[F("max")] = presetCycleMax;
  ccnf[F("time")] = presetCycleTime;
  
  JsonObject nl = root.createNestedObject("nl");
  nl["on"] = nightlightActive;
  nl[F("dur")] = nightlightDelayMins;
  nl[F("fade")] = (nightlightMode > NL_MODE_SET); //deprecated
  nl[F("mode")] = nightlightMode;
  nl[F("tbri")] = nightlightTargetBri;
  
  JsonObject udpn = root.createNestedObject("udpn");
  udpn[F("send")] = notifyDirect;
  udpn[F("recv")] = receiveNotifications;

  root[F("lor")] = realtimeOverride;

  root[F("mainseg")] = strip.getMainSegmentId();
  
  JsonArray seg = root.createNestedArray("seg");
  for (byte s = 0; s < strip.getMaxSegments(); s++)
  {
    WS2812FX::Segment sg = strip.getSegment(s);
    if (sg.isActive())
    {
      JsonObject seg0 = seg.createNestedObject();
      serializeSegment(seg0, sg, s);
    }
  }
}

//by https://github.com/tzapu/WiFiManager/blob/master/WiFiManager.cpp
int getSignalQuality(int rssi)
{
    int quality = 0;

    if (rssi <= -100)
    {
        quality = 0;
    }
    else if (rssi >= -50)
    {
        quality = 100;
    }
    else
    {
        quality = 2 * (rssi + 100);
    }
    return quality;
}

void serializeInfo(JsonObject root)
{
  root[F("ver")] = versionString;
  root[F("vid")] = VERSION;
  //root[F("cn")] = WLED_CODENAME;
  
  JsonObject leds = root.createNestedObject("leds");
  leds[F("count")] = ledCount;
  leds[F("rgbw")] = useRGBW;
  leds[F("wv")] = useRGBW && (strip.rgbwMode == RGBW_MODE_MANUAL_ONLY || strip.rgbwMode == RGBW_MODE_DUAL); //should a white channel slider be displayed?
  JsonArray leds_pin = leds.createNestedArray("pin");
  leds_pin.add(LEDPIN);
  
  leds[F("pwr")] = strip.currentMilliamps;
  leds[F("maxpwr")] = (strip.currentMilliamps)? strip.ablMilliampsMax : 0;
  leds[F("maxseg")] = strip.getMaxSegments();
  leds[F("seglock")] = false; //will be used in the future to prevent modifications to segment config

  root[F("str")] = syncToggleReceive;
  
  root[F("name")] = serverDescription;
  root[F("udpport")] = udpPort;
  root[F("live")] = (bool)realtimeMode;

  switch (realtimeMode) {
    case REALTIME_MODE_INACTIVE: root["lm"] = ""; break;
    case REALTIME_MODE_GENERIC:  root["lm"] = ""; break;
    case REALTIME_MODE_UDP:      root["lm"] = F("UDP"); break;
    case REALTIME_MODE_HYPERION: root["lm"] = F("Hyperion"); break;
    case REALTIME_MODE_E131:     root["lm"] = F("E1.31"); break;
    case REALTIME_MODE_ADALIGHT: root["lm"] = F("USB Adalight/TPM2"); break;
    case REALTIME_MODE_ARTNET:   root["lm"] = F("Art-Net"); break;
    case REALTIME_MODE_TPM2NET:  root["lm"] = F("tpm2.net"); break;
  }

  if (realtimeIP[0] == 0)
  {
    root[F("lip")] = "";
  } else {
    root[F("lip")] = realtimeIP.toString();
  }

  #ifdef WLED_ENABLE_WEBSOCKETS
  root[F("ws")] = ws.count();
  #else
  root[F("ws")] = -1;
  #endif

  root[F("fxcount")] = strip.getModeCount();
  root[F("palcount")] = strip.getPaletteCount();

  JsonObject wifi_info = root.createNestedObject("wifi");
  wifi_info[F("bssid")] = WiFi.BSSIDstr();
  int qrssi = WiFi.RSSI();
  wifi_info[F("rssi")] = qrssi;
  wifi_info[F("signal")] = getSignalQuality(qrssi);
  wifi_info[F("channel")] = WiFi.channel();
  
  #ifdef ARDUINO_ARCH_ESP32
  #ifdef WLED_DEBUG
    wifi_info[F("txPower")] = (int) WiFi.getTxPower();
    wifi_info[F("sleep")] = (bool) WiFi.getSleep();
  #endif
  root[F("arch")] = "esp32";
  root[F("core")] = ESP.getSdkVersion();
  //root[F("maxalloc")] = ESP.getMaxAllocHeap();
  #ifdef WLED_DEBUG
    root[F("resetReason0")] = (int)rtc_get_reset_reason(0);
    root[F("resetReason1")] = (int)rtc_get_reset_reason(1);
  #endif
  root[F("lwip")] = 0;
  #else
  root[F("arch")] = "esp8266";
  root[F("core")] = ESP.getCoreVersion();
  //root[F("maxalloc")] = ESP.getMaxFreeBlockSize();
  #ifdef WLED_DEBUG
    root[F("resetReason")] = (int)ESP.getResetInfoPtr()->reason;
  #endif
  root[F("lwip")] = LWIP_VERSION_MAJOR;
  #endif
  
  root[F("freeheap")] = ESP.getFreeHeap();
  root[F("uptime")] = millis()/1000 + rolloverMillis*4294967;

  usermods.addToJsonInfo(root);
  
  byte os = 0;
  #ifdef WLED_DEBUG
  os  = 0x80;
  #endif
  #ifndef WLED_DISABLE_ALEXA
  os += 0x40;
  #endif
  #ifndef WLED_DISABLE_BLYNK
  os += 0x20;
  #endif
  #ifndef WLED_DISABLE_CRONIXIE
  os += 0x10;
  #endif
  #ifndef WLED_DISABLE_FILESYSTEM
  os += 0x08;
  #endif
  #ifndef WLED_DISABLE_HUESYNC
  os += 0x04;
  #endif
  #ifdef WLED_ENABLE_ADALIGHT
  os += 0x02;
  #endif
  #ifndef WLED_DISABLE_OTA 
  os += 0x01;
  #endif
  root[F("opt")] = os;
  
  root[F("brand")] = "WLED";
  root[F("product")] = F("FOSS");
  root["mac"] = escapedMac;
}

void serveJson(AsyncWebServerRequest* request)
{
  byte subJson = 0;
  const String& url = request->url();
  if      (url.indexOf("state") > 0) subJson = 1;
  else if (url.indexOf("info")  > 0) subJson = 2;
  else if (url.indexOf("si") > 0) subJson = 3;
  else if (url.indexOf("live")  > 0) {
    serveLiveLeds(request);
    return;
  }
  else if (url.indexOf(F("eff"))   > 0) {
    request->send_P(200, "application/json", JSON_mode_names);
    return;
  }
  else if (url.indexOf(F("pal"))   > 0) {
    request->send_P(200, "application/json", JSON_palette_names);
    return;
  }
  else if (url.length() > 6) { //not just /json
    request->send(  501, "application/json", F("{\"error\":\"Not implemented\"}"));
    return;
  }
  
  AsyncJsonResponse* response = new AsyncJsonResponse(JSON_BUFFER_SIZE);
  JsonObject doc = response->getRoot();

  switch (subJson)
  {
    case 1: //state
      serializeState(doc); break;
    case 2: //info
      serializeInfo(doc); break;
    default: //all
      JsonObject state = doc.createNestedObject("state");
      serializeState(state);
      JsonObject info  = doc.createNestedObject("info");
      serializeInfo(info);
      if (subJson != 3)
      {
        doc[F("effects")]  = serialized((const __FlashStringHelper*)JSON_mode_names);
        doc[F("palettes")] = serialized((const __FlashStringHelper*)JSON_palette_names);
      }
  }
  
  response->setLength();
  request->send(response);
}

#define MAX_LIVE_LEDS 180

bool serveLiveLeds(AsyncWebServerRequest* request, uint32_t wsClient)
{
  AsyncWebSocketClient * wsc;
  if (!request) { //not HTTP, use Websockets
    #ifdef WLED_ENABLE_WEBSOCKETS
    wsc = ws.client(wsClient);
    if (!wsc || wsc->queueLength() > 0) return false; //only send if queue free
    #endif
  }

  uint16_t used = ledCount;
  uint16_t n = (used -1) /MAX_LIVE_LEDS +1; //only serve every n'th LED if count over MAX_LIVE_LEDS
  char buffer[2000];
  strcpy_P(buffer, PSTR("{\"leds\":["));
  obuf = buffer;
  olen = 9;

  for (uint16_t i= 0; i < used; i += n)
  {
    olen += sprintf(obuf + olen, "\"%06X\",", strip.getPixelColor(i));
  }
  olen -= 1;
  oappend((const char*)F("],\"n\":"));
  oappendi(n);
  oappend("}");
  if (request) {
    request->send(200, "application/json", buffer);
  }
  #ifdef WLED_ENABLE_WEBSOCKETS
  else {
    wsc->text(obuf, olen);
  }
  #endif
  return true;
}