From 99f4774e144accafe6667f4dc79ca676438a5ca9 Mon Sep 17 00:00:00 2001
From: gemu <gmutz2010@googlemail.com>
Date: Sat, 9 Mar 2024 09:19:04 +0100
Subject: [PATCH] core3 fixes (#20895)

---
 .../tasmota_xdrv_driver/xdrv_10_scripter.ino  | 679 ++++++++++++------
 1 file changed, 471 insertions(+), 208 deletions(-)

diff --git a/tasmota/tasmota_xdrv_driver/xdrv_10_scripter.ino b/tasmota/tasmota_xdrv_driver/xdrv_10_scripter.ino
index a3753a8ca..b41d639d9 100755
--- a/tasmota/tasmota_xdrv_driver/xdrv_10_scripter.ino
+++ b/tasmota/tasmota_xdrv_driver/xdrv_10_scripter.ino
@@ -49,7 +49,7 @@ keywords if then else endif, or, and are better readable for beginners (others m
 // float = 4, double = 8 bytes
 
 
-const uint8_t SCRIPT_VERS[2] = {5, 2};
+const uint8_t SCRIPT_VERS[2] = {5, 3};
 
 #define SCRIPT_DEBUG 0
 
@@ -81,6 +81,17 @@ const uint8_t SCRIPT_VERS[2] = {5, 2};
 #define SCRIPT_MAXSSIZE 48
 #endif
 
+//#define SCRIPT_MAX_SBSIZE SCRIPT_MAXSSIZE
+#define SCRIPT_MAX_SBSIZE glob_script_mem.max_ssize
+
+#ifndef SCRIPT_GC_OPTIONS_SIZE
+#define SCRIPT_GC_OPTIONS_SIZE 320
+#endif
+
+#ifndef SCRIPT_WS_LINE_SIZE
+#define SCRIPT_WS_LINE_SIZE 256
+#endif
+
 #ifndef SCRIPT_CMDMEM
 #define SCRIPT_CMDMEM 512
 #endif
@@ -166,8 +177,13 @@ char *Get_esc_char(char *cp, char *esc_chr);
 #endif
 
 #ifdef ESP32
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
 #include <driver/i2s.h>
+#else
+#include <esp_adc/adc_oneshot.h>
+#include <esp_adc/adc_continuous.h>
 #endif
+#endif // ESP32
 
 #ifdef USE_SCRIPT_TIMER
 #include <Ticker.h>
@@ -567,6 +583,15 @@ struct SCRIPT_MEM {
     uint8_t wsp;
 #endif
 
+#ifdef ESP8266
+    uint8_t pwmpin[5];
+#endif
+#ifdef ESP32
+    uint8_t pwmpin[8];
+    uint8 esp32_beep_pin;
+    TimerHandle_t beep_th;
+#endif
+
 } glob_script_mem;
 
 
@@ -631,6 +656,7 @@ char *eval_sub(char *lp, TS_FLOAT *fvar, char *rstr);
 int32_t script_ow(uint8_t sel, uint32_t val);
 int32_t script_logfile_write(char *path, char *payload, uint32_t size);
 void script_sort_array(TS_FLOAT *array, uint16_t size);
+uint32_t Touch_Status(int32_t sel);
 
 void ScriptEverySecond(void) {
 
@@ -1147,7 +1173,7 @@ char *script;
     for (uint16_t count = 0; count < glob_script_mem.numvars; count++) {
       char *cp = glob_script_mem.glob_vnp + glob_script_mem.vnp_offset[count];
       if (dvtp[count].bits.is_string) {
-        strlcpy(string, glob_script_mem.glob_snp + (dvtp[count].index * glob_script_mem.max_ssize), SCRIPT_MAXSSIZE);
+        strlcpy(string, glob_script_mem.glob_snp + (dvtp[count].index * glob_script_mem.max_ssize), SCRIPT_MAX_SBSIZE);
       } else {
         f2char(glob_script_mem.fvars[dvtp[count].index], glob_script_mem.script_dprec, glob_script_mem.script_lzero, string, '.');
       }
@@ -1318,7 +1344,7 @@ void Script_PollUdp(void) {
 #ifdef SCRIPT_DEBUG_UDP
             AddLog(LOG_LEVEL_DEBUG, PSTR("SCR: string var found - %s - %d - %d"), vnam, res, index);
 #endif
-            strlcpy(sp, cp + 1, SCRIPT_MAXSSIZE);
+            strlcpy(sp, cp + 1, SCRIPT_MAX_SBSIZE);
           } else {
             // error var not found
           }
@@ -1345,7 +1371,7 @@ void script_udp_sendvar(char *vname, TS_FLOAT *fp, char *sp) {
   if (!glob_script_mem.udp_flags.udp_used) return;
   if (!glob_script_mem.udp_flags.udp_connected) return;
 
-  char sbuf[SCRIPT_MAXSSIZE + 4];
+  char sbuf[SCRIPT_MAX_SBSIZE + 4];
   strcpy(sbuf, "=>");
   strcat(sbuf, vname);
   strcat(sbuf, "=");
@@ -1561,21 +1587,21 @@ TS_FLOAT Get_MFilter(uint8_t index) {
 void Set_MFilter(uint8_t index, TS_FLOAT invar);
 void Set_MFilter(uint8_t index, TS_FLOAT invar) {
   uint8_t *mp = (uint8_t*)glob_script_mem.mfilt;
-  for (uint8_t count = 0; count<MAXFILT; count++) {
+  for (uint8_t count = 0; count < MAXFILT; count++) {
     struct M_FILT *mflp = (struct M_FILT*)mp;
-    if (count==index) {
+    if (count == index) {
       if (mflp->numvals & OR_FILT_MASK) {
         // moving average
         mflp->maccu -= mflp->rbuff[mflp->index];
         mflp->maccu += invar;
         mflp->rbuff[mflp->index] = invar;
         mflp->index++;
-        if (mflp->index>=(mflp->numvals&AND_FILT_MASK)) mflp->index = 0;
+        if (mflp->index >= (mflp->numvals & AND_FILT_MASK)) mflp->index = 0;
       } else {
         // median
         mflp->rbuff[mflp->index] = invar;
         mflp->index++;
-        if (mflp->index>=mflp->numvals) mflp->index = 0;
+        if (mflp->index >= mflp->numvals) mflp->index = 0;
       }
       break;
     }
@@ -2298,7 +2324,7 @@ uint8_t pt_pin;
 
 #define MPT_DEBOUNCE 10
 
-void IRAM_ATTR MP_Timer(void) {
+static void IRAM_ATTR MP_Timer(void) {
   uint32_t level = digitalRead(pt_pin&0x3f);
   uint32_t ms = millis();
   uint32_t time;
@@ -2379,7 +2405,7 @@ void script_sort_string_array(uint8_t num) {
   if (!sa) {
     return;
   }
-  char temp[SCRIPT_MAXSSIZE];
+  char temp[SCRIPT_MAX_SBSIZE];
   bool swapped;
   do {
     swapped = false;
@@ -2436,7 +2462,7 @@ char *isargs(char *lp, uint32_t isind) {
 
     glob_script_mem.last_index_string[isind] = (char*)calloc(glob_script_mem.max_ssize * glob_script_mem.si_num[isind], 1);
     for (uint32_t cnt = 0; cnt < glob_script_mem.siro_num[isind]; cnt++) {
-      char str[SCRIPT_MAXSSIZE];
+      char str[SCRIPT_MAX_SBSIZE];
       GetTextIndexed(str, sizeof(str), cnt, sstart);
       strlcpy(glob_script_mem.last_index_string[isind] + (cnt * glob_script_mem.max_ssize), str, glob_script_mem.max_ssize);
     }
@@ -2479,14 +2505,16 @@ char iob = *cp;
 char *isget(char *lp, char *sp, uint32_t isind, struct GVARS *gv) {
 TS_FLOAT fvar;
   lp = GetNumericArgument(lp, OPER_EQU, &fvar, 0);
-  SCRIPT_SKIP_SPACES
-  char str[SCRIPT_MAXSSIZE];
-  str[0] = 0;
   uint8_t index = fvar;
+  SCRIPT_SKIP_SPACES
+  char str[SCRIPT_MAX_SBSIZE];
+  str[0] = 0;
+  
   if (index < 1) index = 1;
   index--;
   if (gv) gv->strind = index;
   glob_script_mem.sind_num = isind;
+
   if (glob_script_mem.last_index_string[isind]) {
     if (!glob_script_mem.si_num[isind]) {
       if (index <= glob_script_mem.siro_num[isind]) {
@@ -2570,8 +2598,6 @@ char *isvar(char *lp, uint8_t *vtype, struct T_INDEX *tind, TS_FLOAT *fp, char *
         return lp;
     }
 
-
-
     if (*lp == '"') {
       lp++;
       while (*lp != '"') {
@@ -2658,7 +2684,7 @@ char *isvar(char *lp, uint8_t *vtype, struct T_INDEX *tind, TS_FLOAT *fp, char *
                     if (fp) *fp = fvar;
                 } else {
                     *vtype = STYPE;  //|index;
-                    if (sp) strlcpy(sp, glob_script_mem.glob_snp + (index * glob_script_mem.max_ssize), SCRIPT_MAXSSIZE);
+                    if (sp) strlcpy(sp, glob_script_mem.glob_snp + (index * glob_script_mem.max_ssize), SCRIPT_MAX_SBSIZE);
                 }
                 return lp + len;
             }
@@ -2675,7 +2701,7 @@ char *isvar(char *lp, uint8_t *vtype, struct T_INDEX *tind, TS_FLOAT *fp, char *
 
 #ifdef USE_SCRIPT_FULL_JSON_PARSER
   // epoch offset missing in this version
-      char str_value[SCRIPT_MAXSSIZE];
+      char str_value[SCRIPT_MAX_SBSIZE];
       str_value[0]=0;
       TS_FLOAT fv;
       uint32_t res = JsonParsePath(gv->jo, vname, '#', &fv, str_value, sizeof(str_value));
@@ -2702,7 +2728,7 @@ nexit:
           *vtype = STR_RES;
           tind->bits.constant = 1;
           tind->bits.is_string = 1;
-          if (sp) strlcpy(sp, str_value, SCRIPT_MAXSSIZE);
+          if (sp) strlcpy(sp, str_value, SCRIPT_MAX_SBSIZE);
           return lp + len;
         }
       }
@@ -2788,7 +2814,7 @@ nexit:
                 *vtype = STR_RES;
                 tind->bits.constant = 1;
                 tind->bits.is_string = 1;
-                if (sp) strlcpy(sp, str_value, SCRIPT_MAXSSIZE);
+                if (sp) strlcpy(sp, str_value, SCRIPT_MAX_SBSIZE);
                 return lp + len;
               }
 
@@ -2835,7 +2861,7 @@ chknext:
         }
 
         if (!strncmp_XP(lp, XPSTR("asc("), 4)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, gv);
           fvar = str[0];
           goto nfuncexit;
@@ -2949,9 +2975,9 @@ chknext:
           lp = GetNumericArgument(lp + 3, OPER_EQU, &fvar, gv);
           switch ((uint8_t)fvar) {
             case 0:
-              { char ssid[SCRIPT_MAXSSIZE];
+              { char ssid[SCRIPT_MAX_SBSIZE];
               lp = GetStringArgument(lp, OPER_EQU, ssid, 0);
-              char pw[SCRIPT_MAXSSIZE];
+              char pw[SCRIPT_MAX_SBSIZE];
               lp = GetStringArgument(lp, OPER_EQU, pw, 0);
               IPAddress local_IP(192,168,189,1);
               IPAddress gateway(192,168,189,1);
@@ -3008,7 +3034,7 @@ chknext:
 #ifdef USE_FLASH_BDIR
         if (!strncmp_XP(lp, XPSTR("bdir("), 5)) {
           lp = GetNumericArgument(lp + 5, OPER_EQU, &fvar, gv);
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           if (fvar > 1) {
             lp = GetStringArgument(lp, OPER_EQU, str, 0);
           }
@@ -3087,7 +3113,7 @@ chknext:
 #endif
 #ifdef USE_FEXTRACT
         if (!strncmp_XP(lp, XPSTR("cts("), 4)) {
-          char tsin[SCRIPT_MAXSSIZE];
+          char tsin[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, tsin, 0);
           SCRIPT_SKIP_SPACES
           int8_t flg = -1;
@@ -3095,7 +3121,7 @@ chknext:
             lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
             flg = fvar;
           }
-          char tsout[SCRIPT_MAXSSIZE];
+          char tsout[SCRIPT_MAX_SBSIZE];
           cnvts(tsout, tsin, flg);
           if (sp) strlcpy(sp, tsout, glob_script_mem.max_ssize);
           lp++;
@@ -3267,7 +3293,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 //#define DEBUG_FS
 #ifdef USE_SCRIPT_FATFS
         if (!strncmp_XP(lp, XPSTR("fo("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           while (*lp == ' ') lp++;
           uint8_t mode = 0;
@@ -3350,7 +3376,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("fw("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = ForceStringVar(lp + 3, str);
           while (*lp == ' ') lp++;
           lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
@@ -3411,7 +3437,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
              options = fvar;
           }
           uint8_t index = 0;
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           char *cp = str;
           if (glob_script_mem.file_flags[find].is_open) {
             if (glob_script_mem.file_flags[find].is_dir) {
@@ -3514,7 +3540,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("fd("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           ufsp->remove(str);
           goto nfuncexit;
@@ -3561,7 +3587,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 #endif //ESP32 && USE_WEBCAM
 #ifdef USE_SCRIPT_FATFS_EXT
         if (!strncmp_XP(lp, XPSTR("fe("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           // execute script
           File ef = ufsp->open(str, FS_FILE_READ);
@@ -3582,7 +3608,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("fmd("), 4)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, 0);
           fvar = ufsp->mkdir(str);
           goto nfuncexit;
@@ -3597,13 +3623,13 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("frd("), 4)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, 0);
           fvar = ufsp->rmdir(str);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("fx("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           if (ufsp->exists(str)) fvar = 1;
           else fvar = 0;
@@ -3617,11 +3643,11 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
         }
         if (!strncmp_XP(lp, XPSTR("frn("), 4)) {
           // rename a file
-          char fn_from[SCRIPT_MAXSSIZE];
+          char fn_from[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, fn_from, 0);
           SCRIPT_SKIP_SPACES
 
-          char fn_to[SCRIPT_MAXSSIZE];
+          char fn_to[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, fn_to, 0);
           SCRIPT_SKIP_SPACES
 
@@ -3761,7 +3787,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           SCRIPT_SKIP_SPACES
 
           if (find >= SFS_MAX) find = SFS_MAX - 1;
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           if (glob_script_mem.file_flags[find].is_open) {
             uint8_t first = 0;
             for (uint32_t cnt = 0; cnt < alen; cnt++) {
@@ -3792,11 +3818,34 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
 
+        if (!strncmp_XP(lp, XPSTR("frln("), 5)) {
+          lp = GetNumericArgument(lp + 5, OPER_EQU, &fvar, gv);
+          uint8_t find = fvar;
+          lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
+          if (glob_script_mem.file_flags[find].is_open) {
+            // read line
+            char instr[SCRIPT_MAX_SBSIZE];
+            fread_str_fp(&glob_script_mem.files[find], instr, sizeof(instr), fvar);
+            if (sp) strlcpy(sp, instr, glob_script_mem.max_ssize);
+          }
+          len = 0;
+          lp++;
+          goto strexit;
+        }
+        if (!strncmp_XP(lp, XPSTR("ft("), 3)) {
+          lp = GetNumericArgument(lp + 3, OPER_EQU, &fvar, gv);
+          uint8_t find = fvar;
+          if (glob_script_mem.file_flags[find].is_open) {
+            fvar = glob_script_mem.files[find].position();
+          }
+          goto nfuncexit;
+        }
+
         if (!strncmp_XP(lp, XPSTR("fcs("), 4)) {
           lp = GetNumericArgument(lp + 4, OPER_EQU, &fvar, gv);
           uint8_t find = fvar;
           SCRIPT_SKIP_SPACES
-          char delim[SCRIPT_MAXSSIZE];
+          char delim[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, delim, 0);
           SCRIPT_SKIP_SPACES
           lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
@@ -3809,7 +3858,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
             delimc = *lp;
             lp++;
           }
-          char fstr[SCRIPT_MAXSSIZE];
+          char fstr[SCRIPT_MAX_SBSIZE];
           fstr[0] = 0;
           bool match = false;
           uint8_t dstrlen = strlen(delim);
@@ -3859,7 +3908,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 #endif // USE_SCRIPT_FATFS_EXT
         if (!strncmp_XP(lp, XPSTR("fl1("), 4) || !strncmp_XP(lp, XPSTR("fl2("), 4) )  {
           uint8_t lknum = *(lp + 2) & 3;
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, 0);
           if (lknum < 1 || lknum > 2) lknum = 1;
           strlcpy(glob_script_mem.flink[lknum - 1], str, 14);
@@ -3918,7 +3967,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
         }
 #ifdef USE_WEBSEND_RESPONSE
         if (!strncmp_XP(lp, XPSTR("gwr("), 4)) {
-          char delim[SCRIPT_MAXSSIZE];
+          char delim[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, delim, 0);
           SCRIPT_SKIP_SPACES
           lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
@@ -3930,7 +3979,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
             lp++;
           }
 
-          char rstring[SCRIPT_MAXSSIZE];
+          char rstring[SCRIPT_MAX_SBSIZE];
           rstring[0] = 0;
           int8_t index = fvar;
           char *wd = ResponseData();
@@ -4000,10 +4049,10 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 
 #ifdef SCRIPT_GET_HTTPS_JP
         if (!strncmp_XP(lp, XPSTR("gjp("), 4)) {
-          char host[SCRIPT_MAXSSIZE];
+          char host[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, host, 0);
           SCRIPT_SKIP_SPACES
-          char path[SCRIPT_MAXSSIZE];
+          char path[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, path, 0);
           fvar = call2https(host, path);
           goto nfuncexit;
@@ -4012,7 +4061,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 
 #ifdef TESLA_POWERWALL
         if (!strncmp_XP(lp, XPSTR("gpwl("), 5)) {
-          char path[SCRIPT_MAXSSIZE];
+          char path[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 5, OPER_EQU, path, 0);
           fvar = call2pwl(path);
           goto nfuncexit;
@@ -4081,13 +4130,13 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto strexit;
         }
         if (!strncmp_XP(lp, XPSTR("hd("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           fvar = strtol(str, NULL, 16);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("hf("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           SCRIPT_SKIP_SPACES
           if (strlen(str) != 8) {
@@ -4116,13 +4165,26 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("http("), 5)) {
-          char host[SCRIPT_MAXSSIZE];
-          lp = GetStringArgument(lp + 5, OPER_EQU, host, 0);
-          SCRIPT_SKIP_SPACES
-          char request[SCRIPT_MAXSSIZE];
-          lp = GetStringArgument(lp, OPER_EQU, request, 0);
-          SCRIPT_SKIP_SPACES
-          fvar = http_req(host, request);
+          char *host;
+          lp = GetLongIString(lp + 5, &host);
+          if (host) {
+            char *request;
+            SCRIPT_SKIP_SPACES
+            lp = GetLongIString(lp, &request);
+            if (request) {
+              SCRIPT_SKIP_SPACES
+              char header[SCRIPT_MAX_SBSIZE];
+              header[0] = 0;
+              if (*lp != ')') {
+                lp = GetStringArgument(lp, OPER_EQU, header, 0);
+              }
+              fvar = http_req(host, header, request);
+              free(host);
+              free(request);
+            } else {
+              free(host);
+            }
+          }
           goto nfuncexit;
         }
 #ifdef USE_LIGHT
@@ -4160,7 +4222,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
         }
 #endif
         if (!strncmp_XP(lp, XPSTR("hstr("), 5)) {
-          char hstr[SCRIPT_MAXSSIZE];
+          char hstr[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 5, OPER_EQU, hstr, 0);
           uint16_t cnt;
           uint16_t slen = strlen(hstr);
@@ -4178,10 +4240,10 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 
       case 'i':
         if (!strncmp_XP(lp, XPSTR("ins("), 4)) {
-          char s1[SCRIPT_MAXSSIZE];
+          char s1[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, s1, 0);
           SCRIPT_SKIP_SPACES
-          char s2[SCRIPT_MAXSSIZE];
+          char s2[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, s2, 0);
           SCRIPT_SKIP_SPACES
           char *cp = strstr(s1, s2);
@@ -4285,6 +4347,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 
 #ifdef ESP32
 #ifdef USE_I2S_AUDIO
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
         if (!strncmp_XP(lp, XPSTR("i2sw("), 5)) {
           TS_FLOAT port;
           lp = GetNumericArgument(lp + 5, OPER_EQU, &port, gv);
@@ -4308,6 +4371,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           }
           goto nfuncexit;
         }
+#endif
 #endif // USE_I2S_AUDIO
 #endif // ESP32
         if (!strncmp_XP(lp, XPSTR("i("), 2)) {
@@ -4328,7 +4392,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           switch (selector) {
             case 0:
               // start streaming
-              char url[SCRIPT_MAXSSIZE];
+              char url[SCRIPT_MAX_SBSIZE];
               lp = GetStringArgument(lp, OPER_EQU, url, 0);
               TS_FLOAT xp, yp, scale ;
               lp = GetNumericArgument(lp, OPER_EQU, &xp, 0);
@@ -4394,9 +4458,9 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 #ifdef USE_UFILESYS
 #ifdef USE_SCRIPT_FATFS_EXT
         if (!strncmp_XP(lp, XPSTR("lfw("), 4)) {
-          char path[SCRIPT_MAXSSIZE];
+          char path[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, path, 0);
-          char payload[SCRIPT_MAXSSIZE];
+          char payload[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, payload, 0);
           lp = GetNumericArgument(lp, OPER_EQU, &fvar, 0);
           // write to logfile
@@ -4596,9 +4660,13 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
         }
 #if  defined(ESP32) && (defined(USE_I2S_AUDIO) || defined(USE_TTGO_WATCH) || defined(USE_M5STACK_CORE2))
         if (!strncmp_XP(lp, XPSTR("pl("), 3)) {
-          char path[SCRIPT_MAXSSIZE];
+          char path[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, path, 0);
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
           Play_mp3(path);
+#else
+          I2SPlayMp3(path);
+#endif
           len++;
           len = 0;
           goto exit;
@@ -4689,7 +4757,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           uint16_t alen;
           TS_FLOAT *array;
           lp = get_array_by_name(lp + 4, &array, &alen, 0);
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, str, 0);
           uint32_t raddr = strtol(str, NULL, 16);
           raddr &= 0xfffffffc;
@@ -4718,7 +4786,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
 /*
 #if defined(ESP32) && (defined(USE_I2S_AUDIO) || defined(USE_M5STACK_CORE2) || defined(ESP32S3_BOX) || defined(USE_I2S_MIC))
         if (!strncmp_XP(lp, XPSTR("rec("), 4)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, 0);
           //SCRIPT_SKIP_SPACES
           //lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
@@ -4762,6 +4830,14 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto nfuncexit;
         }
 #endif
+        if (!strncmp_XP(lp, XPSTR("rwd("), 4)) {
+          // get and return integer
+          lp = GetNumericArgument(lp + 4, OPER_EQU, &fvar, gv);
+          uint32_t ivar = *(uint32_t*)&fvar;
+          ivar = *(uint32_t*)ivar;
+          *(uint32_t*)&fvar = ivar; 
+          goto nfuncexit;
+        }
         break;
 
       case 's':
@@ -4792,13 +4868,13 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto exit;
         }
         if (!strncmp_XP(lp, XPSTR("sl("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           fvar = strlen(str);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("sb("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           SCRIPT_SKIP_SPACES
           TS_FLOAT fvar1;
@@ -4818,7 +4894,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
           goto strexit;
         }
         if (!strncmp_XP(lp, XPSTR("st("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           SCRIPT_SKIP_SPACES
           char token[2];
@@ -4857,7 +4933,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
               } else {
                 // get string before token
                 fvar = -fvar;
-                char cstr[SCRIPT_MAXSSIZE];
+                char cstr[SCRIPT_MAX_SBSIZE];
                 strcpy(cstr, str);
                 for (uint8_t cnt = 1; cnt <= fvar; cnt++) {
                   if (cnt == fvar - 1) {
@@ -4900,7 +4976,7 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
             isint = is_int_var(lp);
           }
           lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           if (isint) {
             double dvar = *(int32_t*)&fvar;
             f2char(dvar, dprec, lzero, str, dsep);
@@ -4914,9 +4990,13 @@ extern void W8960_SetGain(uint8_t sel, uint16_t value);
         }
 #if  defined(ESP32) && (defined(USE_I2S_AUDIO) || defined(USE_TTGO_WATCH) || defined(USE_M5STACK_CORE2))
         if (!strncmp_XP(lp, XPSTR("say("), 4)) {
-          char text[SCRIPT_MAXSSIZE];
+          char text[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, text, 0);
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
           Say(text);
+#else
+          //CmndI2SSay(text);
+#endif
           len++;
           len = 0;
           goto exit;
@@ -4997,7 +5077,7 @@ extern char *SML_GetSVal(uint32_t index);
           if (fvar > 0) {
             if (sp) strlcpy(sp, SML_GetSVal(fvar), glob_script_mem.max_ssize);
           } else {
-            char sbuff[SCRIPT_MAXSSIZE];
+            char sbuff[SCRIPT_MAX_SBSIZE];
             fvar = fabs(fvar);
             if (fvar < 1) {
               fvar = 1;
@@ -5019,13 +5099,13 @@ extern char *SML_GetSVal(uint32_t index);
             lp = GetNumericArgument(lp, OPER_EQU, &fvar3, gv);
             fvar = SML_SetBaud(fvar1, fvar3);
           } else if (fvar2 == 1) {
-            char str[SCRIPT_MAXSSIZE];
+            char str[SCRIPT_MAX_SBSIZE];
             lp = GetStringArgument(lp, OPER_EQU, str, 0);
             fvar = SML_Write(fvar1, str);
           } else if (fvar2 == 2) {
-            char str[SCRIPT_MAXSSIZE];
+            char str[SCRIPT_MAX_SBSIZE];
             str[0] = 0;
-            fvar = SML_Read(fvar1, str, SCRIPT_MAXSSIZE);
+            fvar = SML_Read(fvar1, str, SCRIPT_MAX_SBSIZE);
             if (sp) strlcpy(sp, str, glob_script_mem.max_ssize);
             lp++;
             len = 0;
@@ -5137,7 +5217,7 @@ extern char *SML_GetSVal(uint32_t index);
           goto nfuncexit;
         }
         if (!strncmp_XP(lp, XPSTR("sw("), 3)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 3, OPER_EQU, str, 0);
           fvar = -1;
           if (glob_script_mem.sp) {
@@ -5183,7 +5263,7 @@ extern char *SML_GetSVal(uint32_t index);
         }
         if (!strncmp_XP(lp, XPSTR("sr("), 3)) {
           uint16_t size = glob_script_mem.max_ssize;
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           memset(str, 0, size);
           lp += 3;
           uint8_t runt = 0;
@@ -5603,8 +5683,8 @@ extern char *SML_GetSVal(uint32_t index);
 #ifdef USE_FEXTRACT
         if (!strncmp_XP(lp, XPSTR("s2t("), 4)) {
           lp = GetNumericArgument(lp + 4, OPER_EQU, &fvar, 0);
-          char str[SCRIPT_MAXSSIZE];
-          s2tstamp(str, SCRIPT_MAXSSIZE, fvar, 0);
+          char str[SCRIPT_MAX_SBSIZE];
+          s2tstamp(str, SCRIPT_MAX_SBSIZE, fvar, 0);
           if (sp) strlcpy(sp, str, glob_script_mem.max_ssize);
           len = 0;
           goto strexit;
@@ -5729,7 +5809,7 @@ extern char *SML_GetSVal(uint32_t index);
 
 #ifdef USE_FEXTRACT
         if (!strncmp_XP(lp, XPSTR("tso("), 4)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, 0);
           fvar = -1;
           SCRIPT_SKIP_SPACES
@@ -5747,7 +5827,7 @@ extern char *SML_GetSVal(uint32_t index);
           goto strexit;
         }
         if (!strncmp_XP(lp, XPSTR("tsn("), 4)) {
-          char str[SCRIPT_MAXSSIZE];
+          char str[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, str, 0);
           fvar = tstamp2l(str);
           goto nfuncexit;
@@ -5793,11 +5873,11 @@ extern char *SML_GetSVal(uint32_t index);
           goto notfound;
         }
         if (!strncmp_XP(lp, XPSTR("udp("), 4)) {
-          char url[SCRIPT_MAXSSIZE];
+          char url[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 4, OPER_EQU, url, 0);
           TS_FLOAT port;
           lp = GetNumericArgument(lp, OPER_EQU, &port, gv);
-          char payload[SCRIPT_MAXSSIZE];
+          char payload[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, payload, 0);
           fvar = udp_call(url, port, payload);
           goto nfuncexit;
@@ -5915,7 +5995,7 @@ extern char *SML_GetSVal(uint32_t index);
         }
 #ifdef xUSE_SHINE
         if (!strncmp_XP(vname, XPSTR("wav2mp3("), 8)) {
-          char path[SCRIPT_MAXSSIZE];
+          char path[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 8, OPER_EQU, path, 0);
           fvar = wav2mp3(path);
           goto nfuncexit;
@@ -5966,7 +6046,7 @@ extern char *SML_GetSVal(uint32_t index);
         }
         if (!strncmp_XP(lp, XPSTR("wsrs("), 5)) {
           fvar = 0;
-          char buff[SCRIPT_MAXSSIZE];
+          char buff[SCRIPT_MAX_SBSIZE];
           if (glob_script_mem.tcp_server) {
             if (glob_script_mem.tcp_client.connected()) {
                 uint16_t slen = glob_script_mem.tcp_client.available();
@@ -5984,7 +6064,7 @@ extern char *SML_GetSVal(uint32_t index);
         }
         if (!strncmp_XP(lp, XPSTR("wsws("), 5)) {
           fvar = 0;
-          char buff[SCRIPT_MAXSSIZE];
+          char buff[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp + 5, OPER_EQU, buff, 0);
           if (glob_script_mem.tcp_server) {
             if (glob_script_mem.tcp_client.connected()) {
@@ -6099,7 +6179,17 @@ extern char *SML_GetSVal(uint32_t index);
           goto nfuncexit;
         }
 #endif
+        if (!strncmp_XP(lp, XPSTR("wwd("), 4)) {
+          // write integer
+          lp = GetNumericArgument(lp + 4, OPER_EQU, &fvar, gv);
+          uint32_t ivar = *(uint32_t*)&fvar;
+          lp = GetNumericArgument(lp, OPER_EQU, &fvar, gv);
+          uint32_t lval = *(uint32_t*)&fvar;
+          *(uint32_t*)ivar = lval;
+          goto nfuncexit;
+        }
         break;
+
       case 'y':
         if (!strncmp_XP(vname, XPSTR("year"), 4)) {
           fvar = RtcTime.year;
@@ -6337,7 +6427,7 @@ char *GetStringArgument(char *lp, uint8_t lastop, char *cp, struct GVARS *gv) {
   uint8_t vtype;
   char *slp;
   struct T_INDEX ind;
-  char str[SCRIPT_MAXSSIZE],str1[SCRIPT_MAXSSIZE];
+  char str[SCRIPT_MAX_SBSIZE],str1[SCRIPT_MAX_SBSIZE];
   while (*lp == ' ') { lp++; } // skip leading spaces
   while (1) {
     lp = isvar(lp, &vtype, &ind, 0, str1, gv);
@@ -6507,18 +6597,44 @@ struct T_INDEX ind;
 char *GetLongIString(char *lp, char **dstr) {
   while (*lp == ' ') lp++;
   if (*lp != '"') {
-    *dstr = (char*)malloc(SCRIPT_MAXSSIZE);
+    *dstr = (char*)malloc(SCRIPT_MAX_SBSIZE);
     if (!*dstr) return lp;
     lp = GetStringArgument(lp, OPER_EQU, *dstr, 0);
   } else {
     lp++;
-    char *cp = strchr(lp, '"');
+
+    char *cp;
+#if 0
+    cp = strchr(lp, '"');
     if (cp) {
       uint16_t slen = (uint32_t)cp - (uint32_t)lp;
       *dstr = (char*)calloc(slen + 2, 1);
       if (!*dstr) return lp;
-      memmove(*dstr, lp, slen);
+      memmove(*dstr, lp , slen);
+#else   
+    char *llp = lp;
+ loop:
+    cp = strchr(lp, '"');
+    if (cp) {
+      if (*(cp - 1) == '\\') {
+        lp = cp + 1;
+        goto loop;
+      }
+      uint16_t slen = (uint32_t)cp - (uint32_t)llp;
+      *dstr = (char*)calloc(slen + 2, 1);
+      if (!*dstr) return lp;
+      memmove(*dstr, llp , slen);
+      // Get_esc_char
+      char *tp = *dstr;
+      while (*llp != '"') {
+        char iob;
+        llp = Get_esc_char(llp, &iob);
+        *tp++ = iob;
+      }
+      *tp = 0;
+#endif
       lp = cp + 1;
+      //AddLog(LOG_LEVEL_INFO, PSTR("long string: %s"), *dstr);
     } else {
       // error
     }
@@ -6666,7 +6782,7 @@ void Replace_Cmd_Vars(char *srcbuf, uint32_t srcsize, char *dstbuf, uint32_t dst
     TS_FLOAT fvar;
     cp = srcbuf;
     struct T_INDEX ind;
-    char string[SCRIPT_MAXSSIZE];
+    char string[SCRIPT_MAX_SBSIZE];
     dstsize -= 2;
     for (count = 0; count < dstsize; count++) {
         if (srcsize && (*cp == SCRIPT_EOL)) break;
@@ -6859,14 +6975,14 @@ exit0:
   lp = GetNumericArgument(lp, OPER_EQU, dfvar, gv);
   if (glob_script_mem.glob_error==1) {
     // was string, not number
-	  char cmpstr[SCRIPT_MAXSSIZE];
+	  char cmpstr[SCRIPT_MAX_SBSIZE];
     lp = slp;
     numeric = 0;
     // get the string
     lp = isvar(lp, &vtype, &ind, 0, cmpstr, gv);
 	  lp = getop(lp, &lastop);
     // compare string
-    char str[SCRIPT_MAXSSIZE];
+    char str[SCRIPT_MAX_SBSIZE];
     lp = GetStringArgument(lp, OPER_EQU, str, gv);
     if (lastop==OPER_EQUEQU || lastop==OPER_NOTEQU) {
       res = strcmp(cmpstr, str);
@@ -6923,59 +7039,93 @@ exit10:
   return lp;
 }
 
-#ifdef ESP32
 
-TimerHandle_t beep_th;
+#ifdef ESP32
 void StopBeep( TimerHandle_t xTimer );
 
+
 void StopBeep( TimerHandle_t xTimer ) {
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
   ledcWriteTone(7, 0);
+#else
+  ledcWriteTone(glob_script_mem.esp32_beep_pin, 0);
+#endif
+
   xTimerStop(xTimer, 0);
 }
 
+
+
 void esp32_beep(int32_t freq ,uint32_t len) {
   if (freq<0) {
     if (freq <= -64) freq = 0;
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
     ledcSetup(7, 500, 10);
     ledcAttachPin(-freq, 7);
     ledcWriteTone(7, 0);
-    if (!beep_th) {
-      beep_th = xTimerCreate("beep", 100, pdFALSE, ( void * ) 0, StopBeep);
+#else
+    glob_script_mem.esp32_beep_pin = abs(freq);
+    if (glob_script_mem.esp32_beep_pin == 64) {
+      glob_script_mem.esp32_beep_pin = 0;
+    }
+    ledcAttach(glob_script_mem.esp32_beep_pin, 0, 10);
+#endif
+    if (!glob_script_mem.beep_th) {
+      glob_script_mem.beep_th = xTimerCreate("beep", 100, pdFALSE, ( void * ) 0, StopBeep);
     }
   } else {
-    if (!beep_th) return;
+    if (!glob_script_mem.beep_th) return;
     if (!freq) {
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
       ledcWriteTone(7, 0);
-      xTimerStop(beep_th, 10);
+#else
+      ledcWriteTone(glob_script_mem.esp32_beep_pin, 0);
+#endif
+      xTimerStop(glob_script_mem.beep_th, 10);
       return;
     }
     if (len < 10) return;
-    if (xTimerIsTimerActive(beep_th)) return;
+    if (xTimerIsTimerActive(glob_script_mem.beep_th)) return;
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
     ledcWriteTone(7, freq);
+#else
+    ledcWriteTone(glob_script_mem.esp32_beep_pin, freq);
+#endif
     uint32_t ticks = pdMS_TO_TICKS(len);
-    xTimerChangePeriod( beep_th, ticks, 10);
+    xTimerChangePeriod( glob_script_mem.beep_th, ticks, 10);
   }
 }
-#endif // ESP32
 
-uint8_t pwmpin[5];
+#endif // ESP32
 
 void esp_pwm(int32_t value, uint32 freq, uint32_t channel) {
 
 #ifdef ESP32
   if (channel < 1 || channel > 8) channel = 1;
-  channel += 7;
   if (value < 0) {
     if (value <= -64) value = 0;
     // set range to 10 bit
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
+    channel += 7;
     ledcSetup(channel, freq, 10);
     ledcAttachPin(-value, channel);
     ledcWrite(channel, 0);
+#else
+    glob_script_mem.pwmpin[channel - 1] = abs(value);
+    if (glob_script_mem.pwmpin[channel - 1] == 64) {
+      glob_script_mem.pwmpin[channel - 1] = 0;
+    }
+    ledcAttach(glob_script_mem.pwmpin[channel - 1], freq, 10);
+#endif
   } else {
     if (value > 1023) {
       value = 1023;
     }
+#if !defined(ESP_IDF_VERSION) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5,0,0))
     ledcWrite(channel, value);
+#else
+    ledcWrite(glob_script_mem.pwmpin[channel - 1], value);
+#endif
   }
 #else
   // esp8266 default to range 0-1023
@@ -6983,15 +7133,15 @@ void esp_pwm(int32_t value, uint32 freq, uint32_t channel) {
   channel-=1;
   if (value < 0) {
     if (value <= -64) value = 0;
-    pwmpin[channel] = -value;
-    pinMode(pwmpin[channel], OUTPUT);
+    glob_script_mem.pwmpin[channel] = -value;
+    pinMode(glob_script_mem.pwmpin[channel], OUTPUT);
     analogWriteFreq(freq);
-    AnalogWrite(pwmpin[channel], 0);
+    AnalogWrite(glob_script_mem.pwmpin[channel], 0);
   } else {
     if (value > 1023) {
       value = 1023;
     }
-    AnalogWrite(pwmpin[channel], value);
+    AnalogWrite(glob_script_mem.pwmpin[channel], value);
   }
 #endif // ESP32
 }
@@ -7110,7 +7260,7 @@ int16_t Run_script_sub(const char *type, int8_t tlen, struct GVARS *gv) {
     if_state[ifstck] = 0;
     if_result[ifstck] = 0;
     if_exe[ifstck] = 1;
-    char cmpstr[SCRIPT_MAXSSIZE];
+    char cmpstr[SCRIPT_MAX_SBSIZE];
     TS_FLOAT *dfvar;
 
     TS_FLOAT fvar = 0, fvar1, sysvar, swvar;
@@ -7339,7 +7489,7 @@ getnext:
                   swflg = 1;
                 }
               } else {
-                char str[SCRIPT_MAXSSIZE];
+                char str[SCRIPT_MAX_SBSIZE];
                 lp = GetStringArgument(lp, OPER_EQU, str, 0);
                 if (!strcmp(cmpstr, str)) {
                     swflg = 0x81;
@@ -7380,7 +7530,7 @@ getnext:
                 // mismatch was string, not number
                 lp = slp;
                 glob_script_mem.glob_error = 0;
-                glob_script_mem.retstr = (char*)calloc(SCRIPT_MAXSSIZE, 1);
+                glob_script_mem.retstr = (char*)calloc(SCRIPT_MAX_SBSIZE, 1);
                 if (glob_script_mem.retstr) {
                   lp = GetStringArgument(lp, OPER_EQU, glob_script_mem.retstr, 0);
                 }
@@ -7666,16 +7816,20 @@ getnext:
                 goto next_line;
             } else if (!strncmp(lp, "=(", 2)) {
                 lp += 2;
-                char str[128];
-                str[0] = '>';
-                lp = GetStringArgument(lp, OPER_EQU, &str[1], 0);
-                lp++;
-                //execute_script(str);
-                char *svd_sp = glob_script_mem.scriptptr;
-                strcat(str, "\n#");
-                glob_script_mem.scriptptr = str;
-                Run_script_sub(">", 1, gv);
-                glob_script_mem.scriptptr = svd_sp;
+                //char str[128];
+                char *str = (char*)calloc(128, 1);
+                if (str) {
+                  str[0] = '>';
+                  lp = GetStringArgument(lp, OPER_EQU, &str[1], 0);
+                  lp++;
+                  //execute_script(str);
+                  char *svd_sp = glob_script_mem.scriptptr;
+                  strcat(str, "\n#");
+                  glob_script_mem.scriptptr = str;
+                  Run_script_sub(">", 1, gv);
+                  glob_script_mem.scriptptr = svd_sp;
+                  free(str);
+                }
             }
 
             // check for variable result
@@ -7902,7 +8056,7 @@ getnext:
                     sindex = index;
                     saindex = gv->strind;
                     // string result
-                    char str[SCRIPT_MAXSSIZE];
+                    char str[SCRIPT_MAX_SBSIZE];
                     SCRIPT_SKIP_SPACES
                     lp = getop(lp, &lastop);
 #ifdef SCRIPT_LM_SUB
@@ -8076,7 +8230,7 @@ bool script_OneWireCrc8(uint8_t *addr) {
 }
 
 int32_t script_ow(uint8_t sel, uint32_t val) {
-uint32_t res = 0;
+int32_t res = 0;
 uint8_t bits;
 bool invert = false;
 ScriptOneWire *ow = &glob_script_mem.ow;
@@ -8233,8 +8387,10 @@ ScriptOneWire *ow = &glob_script_mem.ow;
             data[cnt] = ow->ds->read();
           }
           if (script_OneWireCrc8(data)) {
-            res = data[0];
-            res |= data[1] << 8;
+            int16_t ires;
+            ires = data[0];
+            ires |= data[1] << 8;
+            res = ires;
           } else {
             res = 0;
           }
@@ -8252,8 +8408,10 @@ ScriptOneWire *ow = &glob_script_mem.ow;
             data[cnt] = ow->dsh->read();
           }
           if (script_OneWireCrc8(data)) {
-            res = data[0];
-            res |= data[1] << 8;
+            int16_t ires;
+            ires = data[0];
+            ires |= data[1] << 8;
+            res = ires;
           } else {
             res = 0;
           }
@@ -9171,7 +9329,7 @@ void Script_Check_Hue(String *response) {
   if (!bitRead(Settings->rule_enabled, 0)) return;
 
   uint8_t hue_script_found = Run_Scripter1(">H", -2, 0);
-  if (hue_script_found!=99) return;
+  if (hue_script_found != 99) return;
 
   char tmp[256];
   uint8_t hue_devs = 0;
@@ -9477,34 +9635,38 @@ bool Script_SubCmd(void) {
 
   int32_t pl = XdrvMailbox.payload;
 
-  char cmdbuff[128];
-  char *cp = cmdbuff;
-  *cp++ = '#';
-  strlcpy(cp, command, sizeof(cmdbuff) - 1);
-  uint8_t tlen = strlen(command);
-  cp += tlen;
-  if (XdrvMailbox.data_len > 0) {
-    *cp++ = '(';
-    uint32_t max_space = sizeof(cmdbuff) - tlen - 4;  // 4 = #()0
-    uint32_t max_len = min(XdrvMailbox.data_len, max_space);
-    strncpy(cp, XdrvMailbox.data, max_len);
-    cp += max_len;
-    *cp++ = ')';
-    *cp = 0;
-  }
-  //toLog(cmdbuff);
-  uint32_t res = Run_Scripter1(cmdbuff, tlen + 1, 0);
-  //AddLog(LOG_LEVEL_INFO,">>%d",res);
-  if (res) {
-    return false;
-  }
-  else {
-    cp = XdrvMailbox.data;
-    while (*cp==' ') cp++;
-    if (isdigit(*cp) || *cp=='-') {
-      Response_P(S_JSON_COMMAND_NVALUE, command, XdrvMailbox.payload);
-    } else {
-      Response_P(S_JSON_COMMAND_SVALUE, command, XdrvMailbox.data);
+  //char cmdbuff[128];
+  char *cmdbuff = (char*)malloc(128);
+  if (cmdbuff) {
+    char *cp = cmdbuff;
+    *cp++ = '#';
+    strlcpy(cp, command, sizeof(cmdbuff) - 1);
+    uint8_t tlen = strlen(command);
+    cp += tlen;
+    if (XdrvMailbox.data_len > 0) {
+      *cp++ = '(';
+      uint32_t max_space = sizeof(cmdbuff) - tlen - 4;  // 4 = #()0
+      uint32_t max_len = min(XdrvMailbox.data_len, max_space);
+      strncpy(cp, XdrvMailbox.data, max_len);
+      cp += max_len;
+      *cp++ = ')';
+      *cp = 0;
+    }
+    //toLog(cmdbuff);
+    uint32_t res = Run_Scripter1(cmdbuff, tlen + 1, 0);
+    free(cmdbuff);
+    //AddLog(LOG_LEVEL_INFO,">>%d",res);
+    if (res) {
+      return false;
+    }
+    else {
+      cp = XdrvMailbox.data;
+      while (*cp==' ') cp++;
+      if (isdigit(*cp) || *cp=='-') {
+        Response_P(S_JSON_COMMAND_NVALUE, command, XdrvMailbox.payload);
+      } else {
+        Response_P(S_JSON_COMMAND_SVALUE, command, XdrvMailbox.data);
+      }
     }
   }
   return true;
@@ -9589,6 +9751,19 @@ uint32_t options = 0;
 #ifdef USE_SCRIPT_SERIAL
   options |= 0x01000000;
 #endif
+#ifdef USE_SCRIPT_ONEWIRE
+  options |= 0x02000000;
+#endif
+#ifdef USE_SCRIPT_TCP_SERVER
+  options |= 0x04000000;
+#endif
+#ifdef USE_SML_SCRIPT_CMD
+  options |= 0x08000000;
+#endif
+#ifdef TESLA_POWERWALL
+  options |= 0x10000000;
+#endif
+
 
   Response_P(PSTR("{\"script\":{\"vers\":%d.%d,\"opts\":%08x}}"), SCRIPT_VERS[0], SCRIPT_VERS[1], options);
 }
@@ -9667,7 +9842,7 @@ bool ScriptCommand(void) {
         lp++;
         while (*lp==' ') lp++;
         TS_FLOAT fvar;
-        char str[SCRIPT_MAXSSIZE];
+        char str[SCRIPT_MAX_SBSIZE];
         glob_script_mem.glob_error = 0;
         TS_FLOAT *fpd = 0;
         uint16_t alend;
@@ -10327,14 +10502,44 @@ uint32_t fsize;
   } else {
 #ifdef USE_FEXTRACT
     if (glob_script_mem.to_time > glob_script_mem.from_time) {
-      char ts[32];
-      s2tstamp(ts, sizeof(ts), glob_script_mem.from_time, 0);
-      int32_t fo_from = opt_fext(&file, ts, ts, 1);
-      s2tstamp(ts, sizeof(ts), glob_script_mem.to_time, 0);
-      //int32_t fo_to = opt_fext(&file, ts, ts, 2);
-      int32_t fo_to = extract_from_file(&file,  ts, ts, -3, 0, 0, 0, 0);
-      if (fo_to < 0) {
-        fo_to = extract_from_file(&file,  ts, ts, -1, 0, 0, 0, 0);
+      char tsf[32];
+      s2tstamp(tsf, sizeof(tsf), glob_script_mem.from_time, 0);
+      char tst[32];
+      s2tstamp(tst, sizeof(tst), glob_script_mem.to_time, 0);
+      int32_t fo_from;
+      int32_t fo_to;
+      // check if index file available
+      char *cp = strchr(path, '.');
+      if (cp) {
+        *cp = 0;
+        strcat(path, ".ind");
+        File fp = ufsp->open(path, FS_FILE_READ);
+        if (fp > 0) {
+          fo_from = opt_fext(&fp, tsf, tsf, 1);
+          fo_to = extract_from_file(&fp,  tst, tst, -3, 0, 0, 0, 0);
+          // read file offsets
+          if (fo_from > 0 && fo_to > 0) {
+            fp.seek(fo_from, SeekSet);
+            fp.readStringUntil('\t');
+            fo_from = fp.readStringUntil('\n').toInt();
+            fp.seek(fo_to, SeekSet);
+            fp.readStringUntil('\t');
+            fo_to = fp.readStringUntil('\n').toInt();
+            fp.close();
+          } else {
+            fp.close();
+            goto slowacc;
+          }
+        } else {
+          goto slowacc;
+        }
+      } else {
+        slowacc:
+        fo_from = opt_fext(&file, tsf, tsf, 1);
+        fo_to = extract_from_file(&file,  tst, tst, -3, 0, 0, 0, 0);
+        if (fo_to < 0) {
+          fo_to = extract_from_file(&file,  tst, tst, -1, 0, 0, 0, 0);
+        }
       }
       if (fo_from >= 0 && fo_to >= 0) {
         script_copy_file(&file, 0, fo_from, fo_to, 1, &client);
@@ -10712,7 +10917,7 @@ uint16_t cipos = 0;
 char *gc_send_labels(char *lp,uint32_t anum) {
   WSContentSend_P("[");
   for (uint32_t cnt = 0; cnt < anum + 1; cnt++) {
-    char label[SCRIPT_MAXSSIZE];
+    char label[SCRIPT_MAX_SBSIZE];
     lp = GetStringArgument(lp, OPER_EQU, label, 0);
     SCRIPT_SKIP_SPACES
     WSContentSend_P(SCRIPT_MSG_GTE1, label);
@@ -10771,6 +10976,7 @@ uint32_t cnt;
 #define WSO_FORCESUBFILE 64
 #define WSO_STOP_DIV 0x80
 
+
 void WCS_DIV(uint8_t flag) {
   if (flag & WSO_NODIV) return;
   if (flag & WSO_STOP_DIV) {
@@ -10929,14 +11135,21 @@ int32_t web_send_file(char mc, char *fname) {
   return -2;
 }
 
+//#define SCRIPT_WEB_DEBUG
+#define WS_LINE_RETURN free(tmp); return 0;
+
 char *web_send_line(char mc, char *lp1) {
-char tmp[256];
+//char tmp[256];
+char *tmp = (char*)malloc(SCRIPT_WS_LINE_SIZE);
+if (!tmp) {
+  return 0;
+}
+
 char center[10];
 uint8_t optflg = 0;
 const char *gc_str;
 
-  Replace_Cmd_Vars(lp1, 1, tmp, sizeof(tmp));
-
+  Replace_Cmd_Vars(lp1, 1, tmp, SCRIPT_WS_LINE_SIZE);
   char *lin = tmp;
 
   if (!strncmp(lin, "so(", 3)) {
@@ -10944,7 +11157,7 @@ const char *gc_str;
     TS_FLOAT var;
     lin = GetNumericArgument(lin + 3, OPER_EQU, &var, 0);
     specopt = var;
-    return lin;
+    WS_LINE_RETURN
   }
 
   if (specopt & WSO_NOCENTER) {
@@ -10961,13 +11174,15 @@ const char *gc_str;
     specopt = WSO_FORCEPLAIN;
     lin = scripter_sub(lin + 1, 0);
     specopt = sflg;
-    return lin;
+    WS_LINE_RETURN
   }
 
   if ((dogui && !(specopt & WSO_FORCEGUI)) || (!dogui && (specopt & WSO_FORCEGUI))) {
   //if ( ((!mc && (*lin != '$')) || (mc == 'w' && (*lin != '$'))) && (!(specopt & WSO_FORCEMAIN)) || (specopt & WSO_FORCEGUI)) {
     // normal web section
-    //AddLog(LOG_LEVEL_INFO, PSTR("normal %s"), lin);
+#ifdef SCRIPT_WEB_DEBUG    
+    AddLog(LOG_LEVEL_INFO, PSTR("WEB GUI section"));
+#endif
     if (*lin == '@') {
       lin++;
       optflg = 1;
@@ -10999,13 +11214,13 @@ const char *gc_str;
       char vname[16];
       ScriptGetVarname(vname, slp, sizeof(vname));
 
-      char left[SCRIPT_MAXSSIZE];
+      char left[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, left, 0);
       SCRIPT_SKIP_SPACES
-      char mid[SCRIPT_MAXSSIZE];
+      char mid[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, mid, 0);
       SCRIPT_SKIP_SPACES
-      char right[SCRIPT_MAXSSIZE];
+      char right[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, right, 0);
       SCRIPT_SKIP_SPACES
 
@@ -11022,7 +11237,7 @@ const char *gc_str;
       char vname[16];
       ScriptGetVarname(vname, slp, sizeof(vname));
 
-      char label[SCRIPT_MAXSSIZE];
+      char label[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, label, 0);
       const char *cp;
       uint8_t uval;
@@ -11049,7 +11264,7 @@ const char *gc_str;
       ScriptGetVarname(vname, slp, sizeof(vname));
 
       SCRIPT_SKIP_SPACES
-      char pulabel[SCRIPT_MAXSSIZE];
+      char pulabel[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, pulabel, 0);
       SCRIPT_SKIP_SPACES
 
@@ -11121,7 +11336,7 @@ const char *gc_str;
       ScriptGetVarname(vname, slp, sizeof(vname));
 
       SCRIPT_SKIP_SPACES
-      char pulabel[SCRIPT_MAXSSIZE];
+      char pulabel[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, pulabel, 0);
       SCRIPT_SKIP_SPACES
 
@@ -11189,10 +11404,10 @@ const char *gc_str;
         ScriptGetVarname(vname, slp, sizeof(vname));
 
         SCRIPT_SKIP_SPACES
-        char ontxt[SCRIPT_MAXSSIZE];
+        char ontxt[SCRIPT_MAX_SBSIZE];
         lp = GetStringArgument(lp, OPER_EQU, ontxt, 0);
         SCRIPT_SKIP_SPACES
-        char offtxt[SCRIPT_MAXSSIZE];
+        char offtxt[SCRIPT_MAX_SBSIZE];
         lp = GetStringArgument(lp, OPER_EQU, offtxt, 0);
 
         char *cp;
@@ -11230,7 +11445,7 @@ const char *gc_str;
       char vname[16];
       ScriptGetVarname(vname, slp, sizeof(vname));
       SCRIPT_SKIP_SPACES
-      char label[SCRIPT_MAXSSIZE];
+      char label[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, label, 0);
       SCRIPT_SKIP_SPACES
       uint16_t tsiz = 70;
@@ -11254,10 +11469,10 @@ const char *gc_str;
       // text
       char *lp = lin + 3;
       char *slp = lp;
-      char str[SCRIPT_MAXSSIZE];
+      char str[SCRIPT_MAX_SBSIZE];
       lp = ForceStringVar(lp, str);
       SCRIPT_SKIP_SPACES
-      char label[SCRIPT_MAXSSIZE];
+      char label[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, label, 0);
       char vname[16];
       ScriptGetVarname(vname, slp, sizeof(vname));
@@ -11277,14 +11492,14 @@ const char *gc_str;
         }
 
         if (*lp != ')') {
-          char type[SCRIPT_MAXSSIZE];
+          char type[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, type, 0);
           SCRIPT_SKIP_SPACES
           // also requires min max values
-          char min[SCRIPT_MAXSSIZE];
+          char min[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, min, 0);
           SCRIPT_SKIP_SPACES
-          char max[SCRIPT_MAXSSIZE];
+          char max[SCRIPT_MAX_SBSIZE];
           lp = GetStringArgument(lp, OPER_EQU, max, 0);
           SCRIPT_SKIP_SPACES
           WCS_DIV(specopt);
@@ -11324,7 +11539,7 @@ const char *gc_str;
 
       bool isint = is_int_var(vname);
 
-      char label[SCRIPT_MAXSSIZE];
+      char label[SCRIPT_MAX_SBSIZE];
       lp = GetStringArgument(lp, OPER_EQU, label, 0);
       SCRIPT_SKIP_SPACES
       uint16_t tsiz = 200;
@@ -11375,7 +11590,9 @@ const char *gc_str;
     // end standard web interface
   } else {
     //  main section interface
-    //AddLog(LOG_LEVEL_INFO, PSTR("main %s"), lin);
+#ifdef SCRIPT_WEB_DEBUG    
+    AddLog(LOG_LEVEL_INFO, PSTR("WEB main section"));
+#endif
     if ( (*lin == mc) || (mc == 'z') || (specopt & WSO_FORCEMAIN)) {
 
 #ifdef USE_GOOGLE_CHARTS
@@ -11385,8 +11602,10 @@ const char *gc_str;
         }
       }
 exgc:
+#ifdef SCRIPT_WEB_DEBUG    
+      AddLog(LOG_LEVEL_INFO, PSTR("WEB GC section"));
+#endif
       char *lp;
-
       char *cp = strstr_P(lin, PSTR("insa("));
       if (cp) {
         // insert array
@@ -11427,7 +11646,7 @@ exgc:
         }
         lp++;
         WSContentSend_P(PSTR("%s"), lp);
-        return lp;
+        WS_LINE_RETURN
       }
 
       cp = strstr_P(lin, PSTR("=#"));
@@ -11443,7 +11662,7 @@ exgc:
         if (cp) {
           WSContentSend_P(PSTR("%s"), cp + 1);
         }
-        return lp;
+        WS_LINE_RETURN
       }
 
       if (!strncmp(lin, "gc(", 3)) {
@@ -11452,7 +11671,11 @@ exgc:
         SCRIPT_SKIP_SPACES
 
         const char *func;
-        char options[312];
+        //char options[SCRIPT_GC_OPTIONS_SIZE];
+        char *options = (char*)malloc(SCRIPT_GC_OPTIONS_SIZE);
+        if (!options) {
+          WS_LINE_RETURN
+        }
         uint8_t nanum = MAX_GARRAY;
         uint8_t y2f = 0;
         uint8_t tonly = 0;
@@ -11491,7 +11714,7 @@ exgc:
         if (type == 'e') {
           WSContentSend_P(SCRIPT_MSG_GTABLEbx, gc_str, chartindex);
           chartindex++;
-          return lp1;
+          WS_LINE_RETURN
         }
 
         char stacked[6];
@@ -11543,7 +11766,7 @@ exgc:
         lp = gc_get_arrays(lp, &arrays[0], &anum, &entries, &ipos);
 
         if (anum > nanum) {
-          return lp1;
+          WS_LINE_RETURN
           //goto nextwebline;
         }
 
@@ -11561,10 +11784,10 @@ exgc:
         if (gs_ctype == 'T') {
           if (anum && !(entries & 1)) {
             WSContentSend_P(SCRIPT_MSG_GTABLEa);
-            char label[SCRIPT_MAXSSIZE];
+            char label[SCRIPT_MAX_SBSIZE];
             lp = GetStringArgument(lp, OPER_EQU, label, 0);
             SCRIPT_SKIP_SPACES
-            char lab2[SCRIPT_MAXSSIZE];
+            char lab2[SCRIPT_MAX_SBSIZE];
             lab2[0] = 0;
             if (*lp != ')') {
               lp = GetStringArgument(lp, OPER_EQU, lab2, 0);
@@ -11610,10 +11833,11 @@ exgc:
             }
           }
           snprintf_P(options,sizeof(options), SCRIPT_MSG_GOPT4);
+          free(options);
         }
         if (tonly) {
           WSContentSend_P("]);");
-          return lp1;
+          WS_LINE_RETURN
           //goto nextwebline;
         }
       } else {
@@ -11624,7 +11848,7 @@ exgc:
 
         // now we have to export the values
         // fetch label part only once in combo string
-        char label[SCRIPT_MAXSSIZE];
+        char label[SCRIPT_MAX_SBSIZE];
         lp = GetStringArgument(lp, OPER_EQU, label, 0);
         SCRIPT_SKIP_SPACES
 
@@ -11727,11 +11951,11 @@ exgc:
         // table complete
         if (tonly) {
           WSContentSend_P("]);");
-          return lp1;
+          WS_LINE_RETURN
           //goto nextwebline;
         }
         // get header
-        char header[SCRIPT_MAXSSIZE];
+        char header[SCRIPT_MAX_SBSIZE];
         lp = GetStringArgument(lp, OPER_EQU, header, 0);
         SCRIPT_SKIP_SPACES
 
@@ -11814,7 +12038,7 @@ exgc:
 #endif //USE_GOOGLE_CHARTS
     }
   }
-  return lp1;
+  WS_LINE_RETURN
 }
 
 #endif //USE_SCRIPT_WEB_DISPLAY
@@ -11825,7 +12049,11 @@ exgc:
 void script_send_email_body(void(*func)(char *)) {
 uint8_t msect = Run_Scripter1(">m", -2, 0);
   if (msect == 99) {
-    char tmp[256];
+    //char tmp[256];
+    char *tmp = (char*)malloc(256);
+    if (!tmp) {
+      return;
+    }
     char *lp = glob_script_mem.section_ptr + 2;
     while (lp) {
       while (*lp == SCRIPT_EOL) {
@@ -11848,6 +12076,7 @@ uint8_t msect = Run_Scripter1(">m", -2, 0);
         lp++;
       }
     }
+    free(tmp);
   } else {
     //client->println("*");
     func((char*)"*");
@@ -11859,7 +12088,11 @@ uint8_t msect = Run_Scripter1(">m", -2, 0);
 void ScriptJsonAppend(void) {
   uint8_t web_script = Run_Scripter1(">J", -2, 0);
   if (web_script==99) {
-    char tmp[256];
+    //char tmp[256];
+    char *tmp = (char*)malloc(256);
+    if (!tmp) {
+      return;
+    }
     char *lp = glob_script_mem.section_ptr + 2;
     while (lp) {
       while (*lp == SCRIPT_EOL) {
@@ -11886,6 +12119,7 @@ void ScriptJsonAppend(void) {
         lp++;
       }
     }
+    free(tmp);
   }
 }
 #endif //USE_SCRIPT_JSON_EXPORT
@@ -12157,13 +12391,23 @@ int32_t url2file(uint8_t fref, char *url) {
 }
 #endif
 
-int32_t http_req(char *host, char *request) {
+//#define HTTP_DEBUG
+int32_t http_req(char *host, char *header, char *request) {
   WiFiClient http_client;
   HTTPClient http;
   int32_t httpCode = 0;
   uint8_t mode = 0;
-  char hbuff[128];
+  //char hbuff[256];
+  char *hbuff = (char*)malloc(256);
+  if (!hbuff) {
+    return -1;
+  }
   strcpy(hbuff, "http://");
+  bool debug = false;
+  if (*host == '@') {
+    host++;
+    debug = true;
+  }
   strcat(hbuff, host);
 
   if (*request == '_') {
@@ -12173,6 +12417,9 @@ int32_t http_req(char *host, char *request) {
 
 #ifdef HTTP_DEBUG
   AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP heap %d"), ESP_getFreeHeap());
+  AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP host %s"), hbuff);
+  AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP request %s"), request);
+  AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP header %s"), header);
 #endif
 
   if (!mode) {
@@ -12180,14 +12427,21 @@ int32_t http_req(char *host, char *request) {
     strcat(hbuff, request);
     //AddLog(LOG_LEVEL_INFO, PSTR("HTTP GET %s"),hbuff);
     http.begin(http_client, hbuff);
+    if (*header) {
+      http.addHeader("Authorization", header);
+    }
     httpCode = http.GET();
   } else {
     // POST
     //AddLog(LOG_LEVEL_INFO, PSTR("HTTP POST %s - %s"),hbuff, request);
     http.begin(http_client, hbuff);
-    http.addHeader("Content-Type", "text/plain");
+    if (*header) {
+      http.addHeader("Authorization", header);
+      http.addHeader("Content-Type", "text/plain");
+    }
     httpCode = http.POST(request);
   }
+  free(hbuff);
 
 #ifdef HTTP_DEBUG
   AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP RESULT %s"), http.getString().c_str());
@@ -12200,9 +12454,11 @@ int32_t http_req(char *host, char *request) {
   strlcpy(TasmotaGlobal.mqtt_data, http.getString().c_str(), ResponseSize());
 #endif
 
-#ifdef HTTP_DEBUG
-  AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP MQTT BUFFER %s"), ResponseData());
-#endif
+//#ifdef HTTP_DEBUG
+  if (debug) {
+    AddLog(LOG_LEVEL_INFO, PSTR("SCR: HTTP MQTT BUFFER %s"), TasmotaGlobal.mqtt_data.c_str());
+  }
+//#endif
 
 //  AddLog(LOG_LEVEL_INFO, PSTR("JSON %s"), wd_jstr);
 //  TasmotaGlobal.mqtt_data = wd_jstr;
@@ -12226,6 +12482,12 @@ int32_t http_req(char *host, char *request) {
 Powerwall powerwall = Powerwall();
 
 int32_t call2pwl(const char *url) {
+  
+  if (*url == '@') {
+    powerwall.GetRequest(String(url));
+    return 0;
+  }
+  
   uint8_t debug = 0;
   if (*url == 'D') {
     url++;
@@ -12236,6 +12498,7 @@ int32_t call2pwl(const char *url) {
     url++;
     cookie = "";
   }
+
   String result = powerwall.GetRequest(String(url), cookie);
   //AddLog(LOG_LEVEL_INFO, PSTR("PWL: result: %s"), result.c_str());
 
@@ -12523,7 +12786,7 @@ int32_t lvgl_test(char **lpp, int32_t p) {
   TS_FLOAT xp, yp, xs, ys, min, max;
   lv_meter_scale_t * scale;
   lv_meter_indicator_t * indic;
-  char str[SCRIPT_MAXSSIZE];
+  char str[SCRIPT_MAX_SBSIZE];
   int32_t res = 0;
 
   switch (p) {