Service Pack 1 PID, FLOAT and TENS types compatib.

lighthub/colorchannel.cpp

@@ -16,6 +16,15 @@ short colorChannel::getChannelAddr(short n)
   return item->getArg(n);
 }
 
+int colorChannel::isActive()
+{
+itemCmd st;
+st.loadItem(item);
+int val = st.getInt();
+debugSerial<< F(" val:")<<val<<endl;
+return val;
+}
+
 int colorChannel::Ctrl(itemCmd cmd, char* subItem, bool toExecute)
 {
 debugSerial<<F("clrCtr: ");
@@ -25,11 +34,12 @@ if (cmd.isCommand()) suffixCode = S_CMD;
    else suffixCode = cmd.getSuffix();
 
 switch(suffixCode)
-{
+{ int vol;
 case S_NOTFOUND:
   // turn on  and set
 toExecute = true;
 case S_SET:
+case S_ESET:
 case S_HSV:
           PixelCtrl(cmd, subItem, toExecute);
           return 1;
@@ -38,6 +48,12 @@ case S_CMD:
       switch (cmd.getCmd())
           {
           case CMD_ON:
+            if (vol=cmd.getPercents()<MIN_VOLUME && vol>=0) 
+                {
+                cmd.setPercents(INIT_VOLUME);
+                cmd.saveItem(item);
+                item->SendStatus(SEND_PARAMETERS | SEND_DEFFERED);
+                };
             PixelCtrl(cmd,subItem, true);
     //        item->SendStatus(SEND_COMMAND | SEND_PARAMETERS );
             return 1;

lighthub/colorchannel.h

@@ -17,6 +17,7 @@ public:
     int Ctrl(itemCmd cmd, char* subItem=NULL, bool toExecute=true) override;
     virtual int PixelCtrl(itemCmd cmd, char* subItem=NULL, bool show=true ) =0;
     short getChannelAddr(short n =0);
+    int isActive() override;
 protected:
   short iaddr;
   short numArgs;

lighthub/item.cpp

@@ -103,7 +103,7 @@ int txt2subItem(char *payload) {
     return cmd;
 }
 
-const short defval[4] = {0, 0, 0, 0}; //Type,Arg,Val,Cmd
+//const short defval[4] = {0, 0, 0, 0}; //Type,Arg,Val,Cmd
 
 Item::Item(aJsonObject *obj)//Constructor
 {
@@ -116,8 +116,8 @@ void Item::Parse() {
     if (isValid()) {
         // Todo - avoid static enlarge for every types
         for (int i = aJson.getArraySize(itemArr); i < 4; i++)
-            aJson.addItemToArray(itemArr, aJson.createItem( (long int)
+            aJson.addItemToArray(itemArr, aJson.createItem( (long int) 0));
-                    int(defval[i]))); //Enlarge item to 4 elements. VAL=int if no other definition in conf
+                   // int(defval[i]) )); //Enlarge item to 4 elements. VAL=int if no other definition in conf
         itemType = aJson.getArrayItem(itemArr, I_TYPE)->valueint;
         itemArg = aJson.getArrayItem(itemArr, I_ARG);
         itemVal = aJson.getArrayItem(itemArr, I_VAL);
@@ -502,42 +502,47 @@ st.setSuffix(suffixCode);
           st.Cmd(0);
       case CMD_VOID:
        {
-         //Parsing integers from payload
+         //Parsing numbers from payload
           short i = 0;
-          int Par[4];
+          short k = 0;
-          while (payload && i < 4)
+          itemCmd Par0 = getNumber((char **) &payload);
-              Par[i++] = getInt((char **) &payload);
+          Par0.setSuffix(suffixCode);
+          if (Par0.getArgType())  i++;
 
+          int Par[3];        
+          while (payload && k < 3)
+              Par[k++] = getInt((char **) &payload);
+          i=i+k; //i=total # of parameters
           switch(suffixCode)
               {case S_HUE:
-                      st.setH(Par[0]);
+                      st.setH(Par0.getInt());
                       break;
                case S_SAT:
-                      st.setS(Par[0]);
+                      st.setS(Par0.getInt());
                       break;
                case S_TEMP:
-                      st.setColorTemp(Par[0]);
+                      st.setColorTemp(Par0.getInt());
                       break;        
                 default:
                     switch (i) //Number of params
                     {
-                      case 1: 
+                      case 1: st=Par0;
-                            if (set255flag)
+                            //if (set255flag)
-                                  st.Percents255(Par[0]);
+                            //      st.Percents255(Par[0]);
-                            else  st.Percents(Par[0]);  //ToDo float
+                            //else  st.Percents(Par[0]);  //ToDo float
                       break;
-                      case 2: st.HS(Par[0],Par[1]);
+                      case 2: st.HS(Par0.getInt(),Par[0]);
                       break;
                       case 3: 
                               if (set255flag)
-                                    st.HSV255(Par[0],Par[1],Par[2]);   
+                                    st.HSV255(Par0.getInt(),Par[0],Par[1]);   
-                              else  st.HSV(Par[0],Par[1],Par[2]);
+                              else  st.HSV(Par0.getInt(),Par[0],Par[1]);
                       break;
                       case 4:
                               if (set255flag)
-                                st.HSV255(Par[0],Par[1],Par[2]);
+                                st.HSV255(Par0.getInt(),Par[0],Par[1]);
-                              else st.HSV(Par[0],Par[1],Par[2]);
+                              else st.HSV(Par0.getInt(),Par[0],Par[1]);
-                              st.setColorTemp(Par[3]);
+                              st.setColorTemp(Par[2]);
                       break;        
                       default:;
                     }
@@ -609,6 +614,7 @@ int Item::Ctrl(itemCmd cmd,  char* subItem)
 
     bool    chActive  = (isActive()>0);
     bool    toExecute = (chActive>0); // execute if channel is active now
+    debugSerial<<endl;
     
           if (itemType != CH_GROUP )
           {
@@ -696,7 +702,7 @@ int Item::Ctrl(itemCmd cmd,  char* subItem)
                         case S_NOTFOUND:
                              toExecute=true;
                         case S_SET:
-                        //case S_ESET:
+                        case S_ESET:
                              if (st.incrementPercents(step))
                              {  
                                st.saveItem(this);
@@ -704,15 +710,19 @@ int Item::Ctrl(itemCmd cmd,  char* subItem)
                              }
                         break;
                         case S_HUE:
+                             if (cmd.isColor()) st.convertTo(ST_HSV);//Extend storage for color channel
                              if (st.incrementH(step))
                              {
+                             st.setSuffix(S_SET);      
                              st.saveItem(this);
                              SendStatus(SEND_PARAMETERS | SEND_DEFFERED);
                              }
                              break;
                         case S_SAT:
+                             if (cmd.isColor()) st.convertTo(ST_HSV);//Extend storage for color channel
                              if (st.incrementS(step))
                              {
+                             st.setSuffix(S_SET);      
                              st.saveItem(this);
                              SendStatus(SEND_PARAMETERS | SEND_DEFFERED);
                              }
@@ -735,7 +745,7 @@ int Item::Ctrl(itemCmd cmd,  char* subItem)
 
                                      // continue processing as SET
                                      case S_SET:
-                                     //case S_ESET:
+                                     case S_ESET:
                                      if ((st.getArgType() == ST_RGB || st.getArgType() == ST_RGBW) &&
                                         (cmd.getArgType() == ST_HSV ) || (cmd.getArgType() == ST_HSV255)) 
                                                                 st.setArgType(cmd.getArgType());
@@ -751,23 +761,26 @@ int Item::Ctrl(itemCmd cmd,  char* subItem)
                                      break;
 
                                      case S_SAT:
-                                     if (itemType == CH_GROUP && cmd.isColor()) st.setArgType(ST_HSV);//Extend storage for group channel
+                                     if (cmd.isColor()) st.convertTo(ST_HSV);//Extend storage for color channel
                                      if (st.setS(cmd.getS()))
                                         { 
+                                          st.setSuffix(S_SET);  
                                           st.saveItem(this);
                                           SendStatus(SEND_PARAMETERS | SEND_DEFFERED);
                                         }
                                      break;
 
                                      case S_HUE:
-                                     if (itemType == CH_GROUP && cmd.isColor()) st.setArgType(ST_HSV);//Extend storage for group channel
+                                     if (cmd.isColor()) st.convertTo(ST_HSV);//Extend storage for color channel
                                      if (st.setH(cmd.getH()))
                                         {
+                                          st.setSuffix(S_SET);    
                                           st.saveItem(this);
                                           SendStatus(SEND_PARAMETERS | SEND_DEFFERED);
                                         }
                                     break;
                                     case S_TEMP:
+                                    //st.setSuffix(suffixCode);  
                                     st.setColorTemp(cmd.getColorTemp());
                                     st.saveItem(this);
                                     SendStatus(SEND_PARAMETERS | SEND_DEFFERED);
@@ -831,10 +844,15 @@ if (driver) //New style modular code
             break;
 
             case CMD_VOID:
+            case CMD_DN:
+            case CMD_UP:
             res = driver->Ctrl(st, subItem, toExecute);
-            debugSerial<<F("Driver Res:")<<res<<endl;
+
             break;
             
+            case CMD_ON:
+            if (chActive) break;
+
             default: //another command
             res = driver->Ctrl(st, subItem);
             if (st.isCommand())
@@ -843,6 +861,7 @@ if (driver) //New style modular code
                         SendStatus(SEND_COMMAND);
                         }
           }
+          debugSerial<<F("Driver Res:")<<res<<endl;
           return res;
         }
 else //Driver not found
@@ -909,11 +928,12 @@ switch (itemType) {
                       if (!tStore.timestamp16) mqttClient.publish("/alarmoff/snsr", itemArr->name);
                       tStore.tempX100=st.getFloat()*100.;         //Save measurement
                       tStore.timestamp16=millisNZ(8) & 0xFFFF;    //And timestamp
-                      debugSerial<<F(" T:")<<F(":")<<tStore.tempX100<<F(" TS:")<<tStore.timestamp16<<endl;
+                      debugSerial<<F(" T:")<<tStore.tempX100<<F(" TS:")<<tStore.timestamp16<<endl;
                       setExt(tStore.asint);
                       }
                       break;
                       case S_SET:
+                      case S_ESET:
                       st.saveItem(this);
                       break;
                      }
@@ -922,13 +942,13 @@ switch (itemType) {
 
       #ifndef MODBUS_DISABLE
               case CH_MODBUS:
-                  modbusDimmerSet(st);
+                  if (toExecute) modbusDimmerSet(st);
                   break;
               case CH_VC:
-                  VacomSetFan(st);
+                  if (toExecute) VacomSetFan(st);
                   break;
               case CH_VCTEMP:
-                  VacomSetHeat(st);
+                  if (toExecute) VacomSetHeat(st);
                   break;
 
      #endif
@@ -1622,6 +1642,7 @@ int Item::SendStatus(int sendFlags) {
         case CMD_RGB:
         sendFlags &= ~SEND_COMMAND; // Not send command for parametrized req
             break;
+
         default:
             debugSerial<<F("Unknown cmd \n");
             sendFlags &= ~SEND_COMMAND;

lighthub/itemCmd.cpp

@@ -238,16 +238,47 @@ bool itemCmd::incrementPercents(int16_t dif)
      par+=dif;
      if (par>100) par=100;
      if (par<0) par=0;
+     param.v=par;
     break;
     case ST_PERCENTS255:
     case ST_HSV255:
      par+=dif;
      if (par>255) par=255;
      if (par<0) par=0;
+    param.v=par;
     break;
+
+    case ST_INT32:
+    case ST_UINT32:
+     par=param.asInt32;
+     par+=dif;
+     if (par>100) par=100;
+     if (par<0) par=0;
+     param.asInt32=par;
+    break;  
+
+    case ST_FLOAT:
+    case ST_FLOAT_CELSIUS:
+    case ST_FLOAT_FARENHEIT:
+     par=param.asfloat;
+     par+=dif;
+     if (par>100) par=100;
+     if (par<0) par=0;
+     param.asfloat=par;
+    break;  
+ 
+    case ST_TENS:
+    
+     par=param.asInt32;
+     par+=dif*10;
+     if (par>1000) par=1000;
+     if (par<0) par=0;
+     param.asInt32=par;
+    break;  
+
    default: return false;
   }
-  param.v=par;
+  
   return true;
 }
 
@@ -332,6 +363,14 @@ itemCmd itemCmd::assignFrom(itemCmd from)
               case ST_PERCENTS:
                    param.v=from.param.v;
                    break;
+              case ST_TENS:
+                   param.v=from.param.asInt32/10;
+                   break;
+              case  ST_INT32:
+              case  ST_UINT32:  
+                   param.v=constrain(from.param.aslong,0,100);
+                   break; 
+
               case ST_HSV255:
                    param.h=from.param.h;
                    //param.s=map(from.param.s,0,255,0,100);
@@ -376,6 +415,12 @@ itemCmd itemCmd::assignFrom(itemCmd from)
               case ST_PERCENTS:
                    param.v=map(from.param.v,0,100,0,255);
                    break;
+              case ST_INT32:
+              case ST_UINT32:
+                   param.v=map(from.param.asInt32,0,100,0,255); //constr
+                   break;
+              case ST_TENS:
+                   param.v=map(from.param.asInt32,0,1000,0,255);                       
               case ST_HSV255:
                    param.h=from.param.h;
                    param.s=from.param.s;
@@ -402,8 +447,22 @@ itemCmd itemCmd::assignFrom(itemCmd from)
 
         case ST_INT32:
         case ST_UINT32:
+        case ST_TENS:
+           switch (from.cmd.itemArgType)
+           {
+            case ST_HS:
+              param.v=getPercents();
+              param.h=from.param.h;
+              param.s=from.param.s; 
+              cmd.itemArgType=ST_HSV;  
+           default:
               param.asInt32=from.param.asInt32;
               cmd.itemArgType=from.cmd.itemArgType;
+           }
+           break;
+        case ST_HS:
+           param.v=from.getPercents();
+           cmd.itemArgType=ST_HSV; 
            break;     
         case ST_FLOAT_FARENHEIT:
             toFarenheit = true;
@@ -442,6 +501,12 @@ itemCmd itemCmd::assignFrom(itemCmd from)
               cmd.itemArgType=from.cmd.itemArgType;
               param=from.param; 
               break;
+              case ST_HS:
+                   param.v=getPercents();
+                   param.h=from.param.h;
+                   param.s=from.param.s; 
+                   cmd.itemArgType=ST_HSV;
+              break;     
            default:
                      debugSerial<<F("Wrong Assignment ")<<from.cmd.itemArgType<<F("->")<<cmd.itemArgType<<endl;
            }
@@ -454,15 +519,20 @@ itemCmd itemCmd::assignFrom(itemCmd from)
         switch (from.cmd.itemArgType)
           {
             case ST_RGBW:
-                  RGBW_flag=true;
+                 // RGBW_flag=true;
             case ST_RGB:
                   param.asInt32=from.param.asInt32;
                   cmd.itemArgType=from.cmd.itemArgType;
-            break;
+                  return *this;
+            //break;
             // Those types are not possible to apply over RGB without convertion toward HSV
+            case ST_FLOAT:
+            case ST_HS:
+            case ST_INT32:
             case ST_PERCENTS255:
             case ST_PERCENTS:
-            case ST_HS:
+            case ST_TENS:
+            case ST_UINT32:
             {
 
              #ifndef ADAFRUIT_LED  
@@ -474,39 +544,48 @@ itemCmd itemCmd::assignFrom(itemCmd from)
               CHSV hsv = rgb2hsv_approximate(rgb);
              #endif 
 
-                 switch (from.cmd.itemArgType){
+              // Calculate volume
+              int vol=0;
+              switch (from.cmd.itemArgType)
+            {  
             case ST_PERCENTS255:
-                            #ifndef ADAFRUIT_LED 
+              vol=map(from.param.v,0,255,0,100);
-                                from.param.h = map(hsv.h, 0, 255, 0, 365);
-                                from.param.s = map(hsv.s, 0, 255, 0, 100);
-                            #else
-                                from.param.h=100;
-                                from.param.s=0;    
-                            #endif    
-                      from.cmd.itemArgType=ST_HSV255;  
               break;
             case ST_PERCENTS:
+              vol=from.param.v;
+              break;
+            case ST_INT32:
+            case ST_UINT32:
+              vol=from.param.asInt32;
+              break; 
+            case ST_TENS:
+              vol=from.param.asInt32/10;
+              break; 
+            case ST_FLOAT:
+              vol=from.param.asfloat;
+              break;
+            case ST_HS:
                #ifndef ADAFRUIT_LED  
+               vol=hsv.v;
+               #else
+               vol=100;
+               #endif 
+            }
+
+              #ifndef ADAFRUIT_LED  
+              // Restoring HSV from RGB
               from.param.h = map(hsv.h, 0, 255, 0, 365);
               from.param.s = map(hsv.s, 0, 255, 0, 100);
               #else
               from.param.h=100;
               from.param.s=0;  
               #endif
-                      //from.param.v = map(from.param.v,0,100,0,255);      
-                      from.cmd.itemArgType=ST_HSV;//255;         
-                      break;
-                      case ST_HS:
 
-                            #ifndef ADAFRUIT_LED     
+              from.cmd.itemArgType=ST_HSV;
-                                from.param.v = hsv.v;
+              from.param.v=vol;
-                            #else
-                                from.param.v=100;
-                            #endif     
-                      from.cmd.itemArgType=ST_HSV; //255
-                      break;
-                 }
             }
+            // Continue processing with filled from HSV 
+/*
            //Converting  current obj to HSV
 
            debugSerial<<F("Conv RGB2HSV:"); from.debugOut();
@@ -514,10 +593,10 @@ itemCmd itemCmd::assignFrom(itemCmd from)
            // Do not convert to RGBx ?
            param=from.param;
            cmd=from.cmd;
-           return *this;
+           return *this; */
 
            case ST_HSV255:
-                HSV255_flag=true;
+                if (from.cmd.itemArgType==ST_HSV255) HSV255_flag=true;
            case ST_HSV:
                 { // HSV_XX to RGB_XX translation code
                 int rgbSaturation;
@@ -659,8 +738,10 @@ float itemCmd::getFloat()
     case ST_UINT32:
     case ST_RGB:
     case ST_RGBW:
-    case ST_TENS:
+   
       return param.aslong;
+     case ST_TENS:
+      return param.aslong/10;  
 
     case ST_PERCENTS:
     case ST_PERCENTS255:
@@ -695,25 +776,57 @@ short itemCmd::getPercents(bool inverse)
     case ST_HSV:
       if (inverse) return 100-param.v; else return param.v;
   
+    case ST_INT32:
+    case ST_UINT32:
+           if (inverse) return constrain(100-param.asInt32,0,100);
+            else return constrain(param.asInt32,0,100); 
+
     case ST_PERCENTS255:
     case ST_HSV255:
       if (inverse) return map(param.v,0,255,100,0);
           else return map(param.v,0,255,0,100);
 
     case ST_FLOAT:
-       if (inverse) return param.asfloat;
+       if (inverse) return constrain (100-param.asfloat,0,100);
-            else return 100-param.asfloat;   
+            else return constrain (param.asfloat,0,100);   
 
     case ST_TENS:
-           if (inverse) return param.asInt32/10;
+           if (inverse) return constrain (100-param.asInt32/10,0,100);
-            else return 100-param.asInt32/10;
+            else return constrain(param.asInt32/10,0,100);
 
 
     default:
-    return 0;
+    return -1;
   }
 }
 
+bool itemCmd::setPercents(int percents)
+{
+  switch (cmd.itemArgType) {
+
+    case ST_PERCENTS:
+    case ST_HSV:
+      param.v=percents;
+    break;
+    case ST_INT32:
+    case ST_UINT32:
+      param.asInt32=percents;
+    break;       
+    case ST_PERCENTS255:
+    case ST_HSV255:
+      param.v=map(percents,0,100,0,255);
+    break;  
+    case ST_FLOAT:
+      param.asfloat=percents;
+    break;   
+    case ST_TENS:
+    param.asInt32 = percents*10;
+    default:
+    return false;
+  }
+return true;  
+}
+
 short itemCmd::getPercents255(bool inverse)
 {
   switch (cmd.itemArgType) {
@@ -723,6 +836,11 @@ short itemCmd::getPercents255(bool inverse)
        if (inverse) return map(param.v,0,100,255,0);
             else return map(param.v,0,100,0,255);  
 
+    case ST_INT32:
+    case ST_UINT32:
+           if (inverse) return map(param.asInt32,0,100,255,0);
+            else return map(param.asInt32,0,100,0,255); 
+
     case ST_PERCENTS255:
     case ST_HSV255:
        if (inverse) return 255-param.v; else return param.v;
@@ -736,8 +854,9 @@ short itemCmd::getPercents255(bool inverse)
             else return map(param.asInt32,0,1000,0,255);
 
 
+
     default:
-    return 0;
+    return -1;
   }
 }
 
@@ -757,6 +876,14 @@ itemCmd itemCmd::setArgType(uint8_t type)
   return *this;
 }
 
+
+itemCmd itemCmd::convertTo(uint8_t type)
+{ 
+  itemCmd out(type,cmd.cmdCode);
+   out.assignFrom(*this);
+  return out;
+}
+
 uint8_t itemCmd::getCmdParam()
 {
   if (isCommand()) return cmd.cmdParam;
@@ -1008,7 +1135,7 @@ char * itemCmd::toString(char * Buffer, int bufLen, int sendFlags )
             snprintf(argPtr, bufLen, "%ld", param.asInt32);
          break;
          case ST_TENS:
-            snprintf(argPtr, bufLen, "%ld.%d", param.asInt32/10, param.asInt32 % 10);
+            snprintf(argPtr, bufLen, "%ld.%d", param.asInt32/10, abs(param.asInt32 % 10));
          break;
          case ST_HSV:
          case ST_HSV255:

lighthub/itemCmd.h

@@ -204,6 +204,7 @@ public:
   uint16_t getH();
   uint16_t getS();
   itemCmd setArgType(uint8_t);
+  itemCmd convertTo(uint8_t);
   itemCmd Percents(int i);
   itemCmd Percents255(int i);
 
@@ -219,6 +220,7 @@ public:
   long int getSingleInt();
   short    getPercents(bool inverse=false);
   short    getPercents255(bool inverse=false);
+  bool     setPercents(int percents);
   uint8_t    getCmd();
   uint8_t    getArgType();
   uint8_t    getCmdParam();

lighthub/modules/out_ac.cpp

@@ -280,6 +280,7 @@ int out_AC::Ctrl(itemCmd cmd,  char* subItem , bool toExecute)
       switch(suffixCode)
       {
       case S_SET:
+      case S_ESET:
           set_tmp = cmd.getInt();
           if (set_tmp >= 10 && set_tmp <= 30)
           {

lighthub/modules/out_dmx.cpp

@@ -30,13 +30,6 @@ int  out_dmx::Status()
 return driverStatus;
 }
 
-int out_dmx::isActive()
-{
-itemArgStore st;
-st.aslong = item->getVal(); //Restore old params
-debugSerial<< F(" val:")<<st.v<<endl;
-return st.v;
-}
 
 int out_dmx::Poll(short cause)
 {

lighthub/modules/out_dmx.h

@@ -15,7 +15,7 @@ public:
     int Poll(short cause) override;
     int Stop() override;
     int Status() override;
-    int isActive() override;
+  
     int getChanType() override;
 //    int Ctrl(itemCmd cmd, char* subItem=NULL) override;
 //    int PixelCtrl(itemCmd cmd) override;

lighthub/modules/out_modbus.cpp

@@ -427,6 +427,7 @@ case S_NOTFOUND:
 toExecute = true;
 debugSerial<<F("Forced execution");
 case S_SET:
+case S_ESET:
           if (!cmd.isValue()) return 0;
 
 //TODO

lighthub/modules/out_motor.cpp

@@ -161,8 +161,8 @@ if (digitalPinHasPWM(pinUp))
   if (inverted) velocity = map(-dif, 0, 10, 255, 0);
   else          velocity = map(-dif, 0, 10, 0, 255);
 
-      if (velocity>255) velocity=255;
+  velocity = constrain (velocity, MIN_PWM, 255);
-      if (velocity<0) velocity=0;
+
       analogWrite(pinUp,velocity);
     }
 
@@ -176,8 +176,7 @@ else if (digitalPinHasPWM(pinDown))
             velocity = map(-dif, 0, 10, 0, 255);
           else velocity = map(-dif, 0, 10, 255, 0);
 
-          if (velocity>255) velocity=255;
+          velocity = constrain (velocity, MIN_PWM, 255);
-          if (velocity<0) velocity=0;
           analogWrite(pinDown,velocity);
         }
 else
@@ -200,11 +199,11 @@ if (digitalPinHasPWM(pinDown))
 {
   //Serial.println("pinDown PWM");
   int velocity; 
-  if (inverted) velocity = map(dif, 0, 10, 255, 0);
+  if (inverted) velocity = map(dif, 0, 20, 255, 0);
-  else          velocity = map(dif, 0, 10, 0, 255);
+  else          velocity = map(dif, 0, 20, 0, 255);
+
+  velocity = constrain (velocity, MIN_PWM, 255);
 
-  if (velocity>255) velocity=255;
-  if (velocity<0) velocity=0;
   analogWrite(pinDown,velocity);
 }
 else
@@ -268,6 +267,7 @@ case S_NOTFOUND:
 toExecute = true;
 debugSerial<<F("Forced execution");
 case S_SET:
+case S_ESET:
           if (!cmd.isValue()) return 0;
           // item->setVal(cmd.getPercents());
           if (item->getExt()) item->setExt(millisNZ()); //Extend motor time

lighthub/modules/out_motor.h

@@ -5,9 +5,10 @@
 #include <item.h>
 
 #ifndef POS_ERR
-#define POS_ERR 2
+#define POS_ERR 5
 #endif
 
+#define MIN_PWM 70
 // The number of simultaniusly working motors
 #ifndef MOTOR_QUOTE
 #define MOTOR_QUOTE 1

lighthub/modules/out_pid.cpp

@@ -77,7 +77,8 @@ bool out_pid::getConfig()
       {store->pid= new PID  (&store->input, &store->output, &store->setpoint, kP, kI, kD, direction);
       if (!store->pid) return false;
       store->pid->SetMode(AUTOMATIC);
-      store->pid->SetOutputLimits(outMin,outMax);
+      //store->pid->SetOutputLimits(outMin,outMax);
+      store->pid->SetSampleTime(5000); 
      
       return true;}
   else errorSerial<<F("PID already initialized")<<endl;    
@@ -136,11 +137,11 @@ int out_pid::Poll(short cause)
 if (store && store->pid && (Status() == CST_INITIALIZED) && item && (item->getCmd()!=CMD_OFF))   
       {
       double prevOut=store->output;  
-      store->pid->Compute();
+      if(store->pid->Compute())
-      if (abs(store->output-prevOut)>OUTPUT_TRESHOLD)
+      //if (abs(store->output-store-prevOut)>OUTPUT_TRESHOLD)
           { 
             aJsonObject * oCmd = aJson.getArrayItem(item->itemArg, 1);
-            itemCmd value((float) store->output);
+            itemCmd value((float) (store->output * (100./255.)));
             executeCommand(oCmd,-1,value);
           }
 
@@ -182,6 +183,7 @@ return 1;
 
 case S_NOTFOUND:
 case S_SET:
+case S_ESET:
 // Setpoint for PID
 if (!cmd.isValue()) return 0;
 store->setpoint=cmd.getFloat();  

lighthub/modules/out_pid.h

@@ -13,6 +13,7 @@ public:
   double output;
   double input;
   double setpoint;
+  float  prevOut; 
   int driverStatus;
 };
 

lighthub/modules/out_pwm.cpp

@@ -83,13 +83,7 @@ int  out_pwm::Status()
 return driverStatus;
 }
 
-int out_pwm::isActive()
+
-{
-itemArgStore st;
-st.aslong = item->getVal(); //Restore old params
-debugSerial<< F(" val:")<<st.v<<endl;
-return st.v;
-}
 
 int out_pwm::Poll(short cause)
 {

lighthub/modules/out_pwm.h

@@ -15,7 +15,7 @@ public:
     int Poll(short cause) override;
     int Stop() override;
     int Status() override;
-    int isActive() override;
+    
     int getChanType() override;
     //int Ctrl(itemCmd cmd, char* subItem=NULL) override;
     int PixelCtrl(itemCmd cmd, char* subItem=NULL, bool show=true ) override;

lighthub/modules/out_spiled.cpp

@@ -87,13 +87,7 @@ int  out_SPILed::Status()
 return driverStatus;
 }
 
-int out_SPILed::isActive()
+
-{
-itemArgStore st;
-st.aslong = item->getVal(); //Restore old params
-debugSerial<< F(" val:")<<st.v<<endl;
-return st.v;
-}
 
 int out_SPILed::Poll(short cause)
 {

lighthub/modules/out_spiled.h

@@ -20,7 +20,6 @@ public:
     int Poll(short cause) override;
     int Stop() override;
     int Status() override;
-    int isActive() override;
     int getChanType() override;
     //int Ctrl(short cmd, short n=0, int * Parameters=NULL,  int suffixCode=0, char* subItem=NULL) override;
     //int Ctrl(itemCmd cmd, char* subItem=NULL) override;

lighthub/utils.cpp

@@ -106,6 +106,40 @@ int getInt(char **chan) {
 }
 
 
+// chan is pointer to pointer to string
+// Function return first retrived number and move pointer to position next after ','
+itemCmd getNumber(char **chan) {
+    itemCmd val(ST_TENS,CMD_VOID);
+    int fract =0; 
+    if (chan && *chan && **chan)
+    {
+    //Skip non-numeric values
+    while (**chan && !(**chan == '-' || (**chan >= '0' && **chan<='9'))) *chan += 1;
+    int ch = atoi(*chan);
+    
+    char * fractptr = strchr(*chan,'.');
+    if (fractptr) 
+    {
+      //  fract = atoi(fractptr);
+      //  *chan = fractptr;
+      fractptr += 1;
+      fract = constrain(*fractptr-'0',0,9);
+    }
+    
+    //Move pointer to next element (after ,)
+    *chan = strchr(*chan, ',');
+    if (*chan) *chan += 1;
+    //Serial.print(F("Par:")); Serial.println(ch);
+    
+    if (fract)
+      val.Tens(ch*10+((ch>0)?fract:-fract));
+    else
+      val.Int((int32_t)ch);
+   }
+   //val.debugOut();
+   return val;
+}
+
 #if defined(ARDUINO_ARCH_ESP32) || defined(ESP8266)
 unsigned long freeRam ()
 {return system_get_free_heap_size();}

lighthub/utils.h

@@ -48,6 +48,7 @@ void SetBytes(uint8_t* addr, uint8_t count, char * out);
 void SetAddr(char * out,  uint8_t* addr);
 uint8_t HEX2DEC(char i);
 int getInt(char ** chan);
+itemCmd getNumber(char ** chan);
 unsigned long freeRam ();
 void parseBytes(const char* str, char separator, byte* bytes, int maxBytes, int base);
 int log(const char *str, ...);

platformio.ini

@@ -582,8 +582,8 @@ platform = atmelsam
 framework = arduino
 board = due
 build_flags = !python get_build_flags.py lighthub21
-;upload_command = arduinoOTA -address 192.168.11.172 -port 65280 -username arduino -password password -b -upload /sketch -sketch $SOURCE
+;upload_command = arduinoOTA -address 192.168.11.172 -port 65280 -username arduino -password password -b -upload /sketch -sketch $SOURCE ;sleep 4
-upload_command = arduinoOTA -address 192.168.88.64 -port 65280 -username arduino -password password -b -upload /sketch -sketch $SOURCE
+upload_command = arduinoOTA -address 192.168.88.64 -port 65280 -username arduino -password password -b -upload /sketch -sketch $SOURCE;sleep 4
 upload_protocol = custom
 lib_ignore = 
        ;DS2482_OneWire   //UNCOMMENT for software 1-wire driver