a

SE/stuff/P5_Automation_can-dev-res-working-1930/P5_Automation_can-dev-res-working-1930.ino

@@ -91,7 +91,7 @@
 
 //#define DEBUG_I2C_driver_Adafruit_PWMServoDriver
 //#define DEBUG_CAN
-//#define DEBUG_QUEUE
+#define DEBUG_QUEUE
 //#define DEBUG_QUEUE_ASSERT
 //#define DEBUG_QUEUE_WAIT 500
 //#define DEBUG_STRUCT_INIT

SE/stuff/P5_Automation_can-dev-res-working-1930/_DISPLAY_func.h

@@ -821,7 +821,7 @@ void DISPLAY_MENU_SELECTOR(DISPLAY_T* DISPLAY_A ,
              
              
                 if(DISPLAY_MENU_SELECTOR_oldEncPos_A > DISPLAY_MENU_SELECTOR_encoderPos_A) {
-                TASK_PORT_ASSOC_SMOOTH_A.Exp_state_level_NEW_DELTA_A = -5;
+                TASK_PORT_ASSOC_SMOOTH_A.Exp_state_level_NEW_DELTA_A = -2;
                 SPFT(minus);SPFT2(encoder,DISPLAY_MENU_SELECTOR_encoderPos_A);SPFT2(old,DISPLAY_MENU_SELECTOR_oldEncPos_A);
                  Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_INDEX_A].DISPLAY_MENU_ITEM_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_ITEM_INDEX_A].Exp_state_level_A);
                              if(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_INDEX_A].DISPLAY_MENU_ITEM_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_ITEM_INDEX_A].Exp_state_level_A > 0) {
@@ -881,7 +881,7 @@ void DISPLAY_MENU_SELECTOR(DISPLAY_T* DISPLAY_A ,
                              */       
                              } //if(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_INDEX_A].DISPLAY_MENU_ITEM_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_ITEM_INDEX_A].Exp_state_level_A > 0) {
                 } else if(DISPLAY_MENU_SELECTOR_oldEncPos_A < DISPLAY_MENU_SELECTOR_encoderPos_A) {
-                            TASK_PORT_ASSOC_SMOOTH_A.Exp_state_level_NEW_DELTA_A = 5;
+                            TASK_PORT_ASSOC_SMOOTH_A.Exp_state_level_NEW_DELTA_A = 1;
                              if(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_INDEX_A].DISPLAY_MENU_ITEM_A[DISPLAY_PHYSICAL_CHAR_A.DISPLAY_MENU_SELECTOR_A[1].DISPLAY_MENU_ITEM_INDEX_A].Exp_state_level_A < 254) {
                                         
                                     SPL();SPFTFT2(millis,debug,748); PROGMEM_CONSOLE_WRITE_CHAR("#748",TASK_TYPE_T_Set_Port_Smooth_forward__);
@@ -898,9 +898,12 @@ void DISPLAY_MENU_SELECTOR(DISPLAY_T* DISPLAY_A ,
                                              encoderPos_t = millis() + 1000 ;
                                              encoderPos_t1 = millis() + 500 ;
                                              encoderPos_t2 = millis() + 250 ;
-                                                                              
                                              _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,  TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 50, ARDUINO_ARRAY_INDEX_NOT_SET) ;
                                              _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,  TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 100, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,  TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 150, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,  TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 200, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,  TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 250, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+
                                         } else if(encoderPos_t2 < millis()  ) {
                                          SPL();
                                          SPFT2(overload,250);SP(encoderPos_t - millis()); PROGMEM_CONSOLE_WRITE_CHAR(">250",TASK_TYPE_T_Set_Port_Smooth_forward__);
@@ -908,11 +911,17 @@ void DISPLAY_MENU_SELECTOR(DISPLAY_T* DISPLAY_A ,
                                              encoderPos_t1 = millis() + 500 ;
                                              encoderPos_t2 = millis() + 250 ;
                                                                                     
-                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 25, ARDUINO_ARRAY_INDEX_NOT_SET) ;
                                              _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 50, ARDUINO_ARRAY_INDEX_NOT_SET) ;
-                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 75, ARDUINO_ARRAY_INDEX_NOT_SET) ;
                                              _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 100, ARDUINO_ARRAY_INDEX_NOT_SET) ;
-                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 125, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 150, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 200, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 250, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 300, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 350, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 400, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 450, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+                                             _Slave_Ports_queue__add(  Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , TASK_TYPE_T_Set_Port_Smooth_forward__ ,TASK_PORT_ASSOC_SMOOTH_A ,millis(), millis() + 500, ARDUINO_ARRAY_INDEX_NOT_SET) ;
+
                                         } else  { 
                                           SPFT2(overload,0); SP(encoderPos_t - millis());
                                         }

SE/stuff/P5_Automation_can-dev-res-working-1930/_Slave_Ports_Status_QUEUE_func.h

@@ -5,9 +5,9 @@ void _Slave_Ports_queue__INIT( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QU
     Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A
     ) {
                 #if defined(DEBUG_STRUCT_INIT) || defined(DEBUG_QUEUE)
-                  Serial.print("#7AA _Slave_Ports_queue__INIT [FLAG][");
-                                Serial.print(ARDUINO_QUEUE_FLAG_QUEUE,BIN);Serial.print("] + [ ");
-                                Serial.print(ARDUINO_QUEUE_FLAG_CANNOT_OVERWRITE, BIN);Serial.print("] +  [ ");Serial.print(ARDUINO_QUEUE_FLAG_QUEUE | ARDUINO_QUEUE_FLAG_CANNOT_OVERWRITE, BIN); Serial.println("]   ");
+                  Serial.print(F("#7AA _Slave_Ports_queue__INIT [FLAG]["));
+                                Serial.print(ARDUINO_QUEUE_FLAG_QUEUE,BIN);Serial.print(F("] + [ "));
+                                Serial.print(ARDUINO_QUEUE_FLAG_CANNOT_OVERWRITE, BIN);Serial.print(F("] +  [ "));Serial.print(ARDUINO_QUEUE_FLAG_QUEUE | ARDUINO_QUEUE_FLAG_CANNOT_OVERWRITE, BIN); Serial.println(F("]   "));
                 #endif
   ARDUINO_ATTR_ARRAY_S__init(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A, 
   ARDUINO_ARRAY_INDEX_LIMIT_QUEUE,
@@ -33,7 +33,7 @@ void _Slave_Ports_queue__INIT( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QU
           //               i);
         //#ifdef DEBUG_QUEUE
         #if defined(DEBUG_STRUCT_INIT) || defined(DEBUG_QUEUE)
-             Serial.println("[#22] _Slave_Ports_queue__INIT  [OK] ");
+             Serial.println(F("[#22] _Slave_Ports_queue__INIT  [OK] "));
         #endif
    }
    
@@ -50,7 +50,7 @@ void _Slave_Ports_queue__list( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QU
     ) {
       int i;
       #if defined(DEBUG_QUEUE)
-        Serial.println("#100[QUEUE][LIST]");
+        Serial.println(F("#100[QUEUE][LIST]"));
        #endif
     
    // #if defined(DEBUG) || defined(DEBUG_QUEUE)
@@ -68,14 +68,14 @@ void _Slave_Ports_queue__list( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QU
           } else {
           
           #if  defined(DEBUG_QUEUE)
-                Serial.print(" $i[");
+                Serial.print(F(" $i["));
                 Serial.print(i);
 
-                 Serial.print("] QUEUE_ID_A: [");
+                 Serial.print(F("] QUEUE_ID_A: ["));
                 Serial.print(Slave_Ports_Status_QUEUE_A[i].QUEUE_ID_A);
-                 Serial.print("] TASK_TYPE_A: [");
+                 Serial.print(F("] TASK_TYPE_A: ["));
                                  Serial.print(Slave_Ports_Status_QUEUE_A[i].TASK_TYPE_A);
-                  Serial.print("] desc: [");
+                  Serial.print(F("] desc: ["));
                  //Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[i].TASK_TYPE_A);
                  //char res;
                  // res = _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[i]._Slave_Ports_queue_task_type);  Serial.print(res);
@@ -85,14 +85,14 @@ void _Slave_Ports_queue__list( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QU
                _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[i].TASK_TYPE_A) ; //(res); //_Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[i]._Slave_Ports_queue_task_type
 
               #if  defined(DEBUG_QUEUE)
-                 Serial.print("] TASK_PORT_ASSOC_A:[");
+                 Serial.print(F("] TASK_PORT_ASSOC_A:["));
                 Serial.print(Slave_Ports_Status_QUEUE_A[i].TASK_PORT_ASSOC_A.Port_ID);
                      
                      
-                    Serial.print("] time_seq_id: ");
+                    Serial.print(F("] time_seq_id: "));
                 Serial.print(Slave_Ports_Status_QUEUE_A[i].time_seq_id);
 
-                     Serial.print("] time_min_run: ");
+                     Serial.print(F("] time_min_run: "));
                 Serial.println(Slave_Ports_Status_QUEUE_A[i].time_min_run);
                 #endif
                 }
@@ -167,26 +167,26 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
      int   DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_PEEK_A = Slave_Ports_Status_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ;
         
          if(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A > 0 and (DEBUG_QUEUE_ASSERT_BEF_POP_COUNT_A != DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A)) { 
-                Serial.println("#162[DEBUG_QUEUE_ASSERT][ERR] [BEF_POP_COUNT_A["); Serial.print(DEBUG_QUEUE_ASSERT_BEF_POP_COUNT_A); Serial.print("]]!=[BEF_POP_QUEUE_COUNT_A["); Serial.print(DEBUG_QUEUE_ASSERT_AFT_BEF_QUEUE_COUNT_A); Serial.primt("]]");
+                Serial.println(F("#162[DEBUG_QUEUE_ASSERT][ERR] [BEF_POP_COUNT_A[")); Serial.print(DEBUG_QUEUE_ASSERT_BEF_POP_COUNT_A); Serial.print(F("]]!=[BEF_POP_QUEUE_COUNT_A[")); Serial.print(DEBUG_QUEUE_ASSERT_AFT_BEF_QUEUE_COUNT_A); Serial.primt(F("]]"));
                 Delay(1000);
         }
         
         
         if(DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_COUNT_A > 0 and (DEBUG_QUEUE_ASSERT_BEF_POP_COUNT_A != DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A)) { 
-                Serial.println("#162[DEBUG_QUEUE_ASSERT][ERR] [AFT_POP_COUNT_A["); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_COUNT_A); Serial.print("]]!=[AFT_POP_QUEUE_COUNT_A["); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_COUNT_A); Serial.primt("]]");
+                Serial.println(F("#162[DEBUG_QUEUE_ASSERT][ERR] [AFT_POP_COUNT_A[")); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_COUNT_A); Serial.print(F("]]!=[AFT_POP_QUEUE_COUNT_A[")); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_COUNT_A); Serial.primt(F("]]"));
                 Delay(1000);
         }
         
         
         
         if(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A > 1 and ( DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_COUNT_A != (DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A - 1))) { 
-                Serial.println("#174[DEBUG_QUEUE_ASSERT][ERR] [AFT_POP_QUEUE_COUNT_A["); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_COUNT_A); Serial.print("]]!=[BEF_POP_QUEUE_COUNT_A -1["); Serial.print(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A); Serial.primt("]]");
+                Serial.println(F("#174[DEBUG_QUEUE_ASSERT][ERR] [AFT_POP_QUEUE_COUNT_A[")); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_COUNT_A); Serial.print(F("]]!=[BEF_POP_QUEUE_COUNT_A -1[")); Serial.print(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A); Serial.primt(F("]]"));
                 Delay(1000);
         }
         
         
         if(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_COUNT_A > 1 and ( DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_PEEK_A != (DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_PEEK_A + 1))) { 
-                Serial.println("#180[DEBUG_QUEUE_ASSERT][ERR] [AFT_POP_QUEUE_PEEK_A["); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_PEEK_A); Serial.print("]]!=[BEF_POP_QUEUE_PEEK_A + 1["); Serial.print(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_PEEK_A); Serial.primt("]]");
+                Serial.println(F("#180[DEBUG_QUEUE_ASSERT][ERR] [AFT_POP_QUEUE_PEEK_A[")); Serial.print(DEBUG_QUEUE_ASSERT_AFT_POP_QUEUE_PEEK_A); Serial.print(F("]]!=[BEF_POP_QUEUE_PEEK_A + 1[")); Serial.print(DEBUG_QUEUE_ASSERT_BEF_POP_QUEUE_PEEK_A); Serial.primt(F("]]"));
                 Delay(1000);
         }
         
@@ -200,10 +200,10 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
 
  // ARDUINO_ARRAY_ATTR_QUEUE_T Slave_Ports_ATTR_QUEUE_A = ARDUINO_ARRAY_ATTR_QUEUE(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A) ;//ARDUINO_ARRAY_INDEX_CURRENT_T Slave_Ports_ATTR_QUEUE_PEEK_A ;// = Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ;
     #if  defined(DEBUG_QUEUE)
-        Serial.println("136 after ARDUINO_ARRAY_INDEX_POP_LOCK"); ARDUINO_ATTR_ARRAY_S__display(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
-        Serial.print(" [POP_LOCK][");Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A); Serial.print("] ");
-        Serial.print(" COUNT_MAX["); Serial.print(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A); 
-       Serial.print("] COUNT_A["); Serial.print(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A); Serial.print("] ");
+        Serial.println(F("136 after ARDUINO_ARRAY_INDEX_POP_LOCK")); ARDUINO_ATTR_ARRAY_S__display(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+        Serial.print(F(" [POP_LOCK]["));Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A); Serial.print(F("] "));
+        Serial.print(F(" COUNT_MAX[")); Serial.print(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A); 
+       Serial.print(F("] COUNT_A[")); Serial.print(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A); Serial.print(F("] "));
     #endif   
                    _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A) ; 
    
@@ -222,8 +222,8 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
         
                  // #if defined(DEBUG)  || defined(DEBUG_QUEUE)
                     // if(DEBUG > 6) {
-                                   Serial.print("#166  [DEBUG]  Error with queue [INDEX_CURR]=["); Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A);
-                                   Serial.println("]  ");
+                                   Serial.print(F("#166  [DEBUG]  Error with queue [INDEX_CURR]=[")); Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A);
+                                   Serial.println(F("]  "));
                              //      }
                    // #endif    
               } else { //if all zeros
@@ -231,11 +231,11 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                     //todo if(QUEUE_LATENCY_PASS__POP(time_seq_id_A,time_min_run_A,time )) {}
                      if(1==2) { //Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_min_run > time) {
                             #if defined(DEBUG_QUEUE)
-                            Serial.print("#182 QUEUE reassign .time_seq_id > millis()  time_seq_id[");     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_seq_id); 
-                            Serial.print("]  millis()["); Serial.print(time);
-                            Serial.print("]  TASK_TYPE_A["); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
-                            Serial.print("]  Will wait() to next ["); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_seq_id);
-                            Serial.print("]  #["); Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A);  Serial.print("]  ID["); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].QUEUE_ID_A);  Serial.println("]  ");  
+                            Serial.print(F("#182 QUEUE reassign .time_seq_id > millis()  time_seq_id["));     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_seq_id); 
+                            Serial.print(F("]  millis()[")); Serial.print(time);
+                            Serial.print(F("]  TASK_TYPE_A[")); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
+                            Serial.print(F("]  Will wait() to next [")); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_seq_id);
+                            Serial.print(F("]  #[")); Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A);  Serial.print(F("]  ID[")); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].QUEUE_ID_A);  Serial.println(F("]  "));  
                             #endif  
                             _Slave_Ports_queue__add( Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , 
                                 Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A,
@@ -245,7 +245,7 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                                 Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A
                               );
                                #if defined(DEBUG_QUEUE)
-                               Serial.print("[WILL DELETE REC]     millis()["); Serial.print(time);
+                               Serial.print(F("[WILL DELETE REC]     millis()[")); Serial.print(time);
                               #endif
                               Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ; //TODO delete by func 
 
@@ -254,7 +254,7 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
             
                      } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_ttl_decrement) {
                             #if  defined(DEBUG_QUEUE)
-                                      Serial.print("#224 running _Slave_Ports_ttl_decrement = ");     Serial.println( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A); Serial.println("]");     
+                                      Serial.print(F("#224 running _Slave_Ports_ttl_decrement = "));     Serial.println( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A); Serial.println(F("]"));     
                             #endif                              
                                       
                                       _Slave_Ports_ttl_decrement_POP(Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A,  ARDUINO_ARRAY_INDEX_POP_LOCK_A ,  Slave_Ports_Status_A ) ;  
@@ -262,7 +262,7 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                                       //TODO STORAGE
                      } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_broadcast____) {
                             #if  defined(DEBUG_QUEUE)
-                                      Serial.print("#337 running _Slave_Ports_broadcast = ");     Serial.println( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A); Serial.println("]");
+                                      Serial.print(F("#337 running _Slave_Ports_broadcast = "));     Serial.println( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A); Serial.println(F("]"));
                             #endif
                                      // #include "_Slave_Ports_ttl_decrement.h"
                                      _Slave_Ports_broadcast_POP(                                     
@@ -296,7 +296,7 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                                       Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ;    //todo storage
                      } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_DISPLAY_queue_pop________ ) {
                       #if  defined(DEBUG_QUEUE)
-                       Serial.print("#212 DISPLAY TASK_TYPE_A[");     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
+                       Serial.print(F("#212 DISPLAY TASK_TYPE_A["));     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
                              Serial.println("] ");
                      #endif   
                         _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A) ;
@@ -305,22 +305,22 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                                // #include "_DISPLAY_queue_pop_func.h"
                                 #if defined(DISABLE_TASK_TYPE_T_DISPLAY_queue_pop________)
                                     #if defined(DEBUG_TASK_TYPE_T_DISPLAY_queue_pop________)
-                                        Serial.println("#250 [DISABLE_TASK_TYPE_T_DISPLAY_queue_pop________]");   
-                                        Serial.print(" DISPLAY_array16_A["); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_array16_A); Serial.print("] ");
-                                        Serial.print(" DISPLAY_pos_seq_A["); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_pos_seq_A, BIN); Serial.print("] ");
-                                        Serial.print(" DISPLAY_TARGET_A["); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_TARGET_A, BIN); Serial.print("] ");
-                                        Serial.print(" DISPLAY_ARDUINO_ARRAY_INDEX_A["); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A); Serial.print("] ");
+                                        Serial.println(F("#250 [DISABLE_TASK_TYPE_T_DISPLAY_queue_pop________]"));   
+                                        Serial.print(F(" DISPLAY_array16_A[")); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_array16_A); Serial.print(F("] "));
+                                        Serial.print(F(" DISPLAY_pos_seq_A[")); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_pos_seq_A, BIN); Serial.print(F("] "));
+                                        Serial.print(F(" DISPLAY_TARGET_A["); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_TARGET_A, BIN); Serial.print(F("] "));
+                                        Serial.print(F(" DISPLAY_ARDUINO_ARRAY_INDEX_A[")); Serial.print(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A); Serial.print(F("] "));
                                     #endif
                                     
                                   Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ;   //todo storage
                                   #if defined(DEBUG_TASK_TYPE_T_DISPLAY_queue_pop________)
-                                   Serial.print("#201 DELETED DISPLAY TASK_TYPE_A #[");     Serial.print( ARDUINO_ARRAY_INDEX_POP_LOCK_A);Serial.println("] ");
+                                   Serial.print(F("#201 DELETED DISPLAY TASK_TYPE_A #["));     Serial.print( ARDUINO_ARRAY_INDEX_POP_LOCK_A);Serial.println(F("] "));
                                   #endif 
                                 #else
-                                Serial.println("3047[Display Text:["); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_string_A);Serial.print("] ");
+                                Serial.println(F("3047[Display Text:[")); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_string_A);Serial.print(F("] "));
                                     #if defined(DEBUG_TASK_TYPE_T_DISPLAY_queue_pop________)
-                                        Serial.print(" DISPLAY_array16_A["); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_array16_A); Serial.print("] ");
-                                        Serial.print("#201 DELETING DISPLAY TASK_TYPE_A #[");     Serial.print( ARDUINO_ARRAY_INDEX_POP_LOCK_A);Serial.println("] ");
+                                        Serial.print(F(" DISPLAY_array16_A[")); Serial.print(DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_array16_A); Serial.print(F("] "));
+                                        Serial.print(F("#201 DELETING DISPLAY TASK_TYPE_A #["));     Serial.print( ARDUINO_ARRAY_INDEX_POP_LOCK_A);Serial.println("] ");
                                     #endif
                                                     DISPLAY__print( DISPLAY_A ,
                                                     DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
@@ -344,7 +344,7 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                                         
                       } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_set_I2C______) {
                                 #if defined(DEBUG_TASK_TYPE_T_Slave_Ports_set_I2C______)
-                                      Serial.print("#221 running TASK_TYPE_T_Slave_Ports_set_I2C______ = ");     Serial.println( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A); Serial.println("]");
+                                      Serial.print(F("#221 running TASK_TYPE_T_Slave_Ports_set_I2C______ = "));     Serial.println( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A); Serial.println(F("]"));
                                 #endif
                                       //#include "_Slave_Ports_ttl_decrement.h"
                                       _Slave_Ports_I2C_POP(
@@ -371,7 +371,7 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                      } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_Broadcast_state_LOW______ ) {
                         
                              #if defined(DEBUG_QUEUE)
-                            Serial.print(" [Q]BCAST>LOW ");
+                            Serial.print(F(" [Q]BCAST>LOW "));
                         #endif
                         TASK_TYPE_T_Broadcast_state_LOW(Slave_Ports_Status_A, Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A);
                                   
@@ -414,16 +414,16 @@ QUEUE_LATENCY_PASS__POP( time_seq_id_T time_seq_id_A,
                         
                      }  else {
                         #if defined(DISABLE_QUEUE_REASSIGN)
-                        Serial.print("$177 [DISABLE_QUEUE_REASSIGN] Error unsupported type TASK_TYPE_A[");     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
+                        Serial.print(F("$177 [DISABLE_QUEUE_REASSIGN] Error unsupported type TASK_TYPE_A["));     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
                              _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A) ;
-                             Serial.println("] REASSIGN NEXT QUEUE FOR FURTHER ACTION");    
+                             Serial.println(F("] REASSIGN NEXT QUEUE FOR FURTHER ACTION"));    
                              SPFTFT2(time,min,Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_min_run)  ;
                              SPFTFT2(time,run,millis())  ;
 
                         #else
-                             Serial.print("$177 Error unsupported type TASK_TYPE_A[");     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
+                             Serial.print(F("$177 Error unsupported type TASK_TYPE_A["));     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
                              _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A) ;
-                             Serial.println("] REASSIGN NEXT QUEUE FOR FURTHER ACTION");     
+                             Serial.println(F("] REASSIGN NEXT QUEUE FOR FURTHER ACTION"));     
                              _Slave_Ports_queue__add( Slave_Ports_Status_QUEUE_A,  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,
                                 Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A,
                                 Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_PORT_ASSOC_A,

SE/stuff/P5_Automation_can-dev-res-working-1930/_Slave_Ports_action_func.h

@@ -94,7 +94,7 @@ Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A,
                     String message ; 
                     byte sndStat = CAN0.sendMsgBuf(Active_ControllerID_HEX, //Active_ControllerID_HEX,
                          0, 8, CAN_MSG8_A_Slave_Ports_Protocol_CAN_request_set_new_Exp_state_A); 
-                    delay(20);
+                   // delay(20);
                      if(sndStat == CAN_OK){
                      
                       Slave_Ports_Status_A[TASK_PORT_ASSOC_A.Slave_Ports_Status_T_INDEX].Exp_state = Slave_Ports_Status_A[TASK_PORT_ASSOC_A.Slave_Ports_Status_T_INDEX].Exp_state |  Exp_state_SET_REQ_SEND ;
@@ -172,7 +172,7 @@ Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A,
                     String message ; 
                     byte sndStat = CAN0.sendMsgBuf(Active_ControllerID_HEX , //Active_ControllerID_HEX, 
                         0, 8, CAN_MSG8_A_Slave_Ports_Protocol_CAN_request_confirm_Exp_state_A); 
-                    delay(20);
+                   // delay(20);
                      if(sndStat == CAN_OK){
                      
                      // Slave_Ports_Status_A[TASK_PORT_ASSOC_A.Slave_Ports_Status_T_INDEX].Exp_state = Slave_Ports_Status_A[TASK_PORT_ASSOC_A.Slave_Ports_Status_T_INDEX].Exp_state |  Exp_state_SET_REQ_SEND ;

SE/stuff/P5_Automation_can-dev-res-working-1930/___CONFIG/0x35/config_Active_ControllerID_0x35.h

@@ -34,7 +34,6 @@
 
 //#define DEBUG_DISPLAY
 
-//#define DEBUG_QUEUE
 
 //#define DEBUG_QUEUE_ASSERT
 

SE/stuff/P5_Automation_can-dev-res-working-1930/___main/__main_struct_funct.h

@@ -284,7 +284,7 @@ ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
       #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
       // || DEBUG_QUEUE)
          #if not defined(DISABLE_ANY_PRINT)
-        Serial.println("[  #297 ARDUINO_ATTR_ARRAY_S__commit_added_element]  [INCREMENTED]  ARDUINO_QUEUE_ELEMENT_FLAG_A[");Serial.print(ARDUINO_QUEUE_ELEMENT_FLAG_A,BIN); Serial.print("]   ");
+        Serial.println(F("[  #297 ARDUINO_ATTR_ARRAY_S__commit_added_element]  [INCREMENTED]  ARDUINO_QUEUE_ELEMENT_FLAG_A["));Serial.print(ARDUINO_QUEUE_ELEMENT_FLAG_A,BIN); Serial.print(F("]   "));
         #endif
       #endif
       
@@ -292,22 +292,22 @@ ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
     if(ARDUINO_ARRAY_INDEX_CURRENT_A == ARDUINO_ARRAY_INDEX_CORRUPT )  {
      #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
          #if not defined(DISABLE_ANY_PRINT)
-        Serial.println("[  #2398 commit_added_element]  [ARDUINO_ARRAY_INDEX_CORRUPT] ignored");
+        Serial.println(F("[  #2398 commit_added_element]  [ARDUINO_ARRAY_INDEX_CORRUPT] ignored"));
          #endif
       #endif
     } else if(ARDUINO_QUEUE_ELEMENT_FLAG_A & ARDUINO_QUEUE_ELEMENT_FLAG_INITIAL_CORRUPT) {
       #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-        Serial.println("[  #3338 commit_added_element]  [ARDUINO_QUEUE_ELEMENT_FLAG_INITIAL_CORRUPT] ignored");
+        Serial.println(F("[  #3338 commit_added_element]  [ARDUINO_QUEUE_ELEMENT_FLAG_INITIAL_CORRUPT] ignored"));
       #endif
     } else {
         //if should index rotate
              #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-                Serial.print("[#555 commit_added_element]  [if should index rotate]?? ");
+                Serial.print(F("[#555 commit_added_element]  [if should index rotate]?? "));
               #endif
                 if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A + 1) >= ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A) {
                      
                       #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-                              Serial.print("   +[ARDUINO_ARRAY_COUNT_A][HIT]   ");
+                              Serial.print(F("   +[ARDUINO_ARRAY_COUNT_A][HIT]   "));
                        #endif
                            
                         
@@ -315,7 +315,7 @@ ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
                         if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A == ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ) {
                                 ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A = ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A ;
                               #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-                                    Serial.print("+set last[PEEK_A]["); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A); Serial.print("]  ");
+                                    Serial.print(F("+set last[PEEK_A][")); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A); Serial.print(F("]  "));
                                #endif
                         }
                         
@@ -326,9 +326,9 @@ ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
                         ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A ++;   
                  #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
                       #if not defined(DISABLE_ANY_PRINT)
-                        Serial.print("433[ELSE] [QUEUE++]");
+                        Serial.print(F("433[ELSE] [QUEUE++]"));
                         Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A);
-                        Serial.print("] ");
+                        Serial.print(F("] "));
                      #endif 
                    #endif
                 
@@ -341,17 +341,17 @@ ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
                  if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A + 1) >= ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A) {
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A = ARDUINO_ARRAY_INDEX_FIRST ;
                       #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-                        Serial.print("[NEXT ROTATE]");
+                        Serial.print(F("[NEXT ROTATE]"));
                         Serial.print( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A);
-                        Serial.print("] ");
+                        Serial.print(F("] "));
                        #endif
                     
                  
                  } else {
                     #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-                        Serial.print("[NEXT ++]");
+                        Serial.print(F("[NEXT ++]"));
                         Serial.print( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A);
-                        Serial.print("] ");
+                        Serial.print(F("] "));
                        #endif
                      ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A++ ;
                  }
@@ -367,7 +367,7 @@ ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
                 if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A > 0) { } else {
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A = ARDUINO_ARRAY_INDEX_CURRENT_A ;
                     #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE)
-                        Serial.print("+init[ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]["); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A); Serial.print("]  ");
+                        Serial.print(F("+init[ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A][")); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A); Serial.print(F("]  "));
                    #endif 
                 }
               return true    ;      
@@ -402,28 +402,35 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_POP_LOCK( ARDUINO_ATTR_ARRAY
                   ARDUINO_ARRAY_INDEX_NEXT_A =  ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ;
                      #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
                              #if not defined(DISABLE_ANY_PRINT)
-                              Serial.print("  [ARDUINO_ARRAY_INDEX_POP_LOCK]?  ");
-                              #endif       
+                              //Serial.print("  [ARDUINO_ARRAY_INDEX_POP_LOCK]?  ");
+                              SPFTFTFTFT2(queue,index,pop,lock,-405);
+                             
+                              #endif
+                                    
                           #endif 
                  if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A > 0) {
                                  #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                     Serial.print("  [INCREMENT][PEEK]  ");    
+                                     //Serial.print("  [INCREMENT][PEEK]  "); 
+                                     SPFTFT(increment,peek);   
                                  #endif 
                       
                             if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A + 1) >= ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A) {
                                   #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                     Serial.print("  [INCREMENT][ROTATE]?  ");    
+                                     //Serial.print("  [INCREMENT][ROTATE]?  ");  
+                                     SPFTFT2(increment,rotate,"?");  
                                  #endif 
                                     if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A == ARDUINO_ARRAY_INDEX_FIRST) {
                                           #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                              Serial.print("  [INCREMENT][=NEXT][QUEUE FORCE 0]  ");    
+                                              //Serial.print("  [INCREMENT][=NEXT][QUEUE FORCE 0]  ");    
+                                              SPFTFTFTFT2(increment,next,queue,force,0);
                                           #endif
                                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A = 0;
                                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A = 0 ; //--;
                                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A = 0 ; //--;
                                     } else {
                                       #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                              Serial.print("  [INCREMENT--][NEXT]=ARDUINO_ARRAY_INDEX_FIRST  ");    
+                                              //Serial.print("  [INCREMENT--][NEXT]=ARDUINO_ARRAY_INDEX_FIRST  "); 
+                                                SPFTFTFTFT(increment,next,index,first) ;
                                           #endif
                                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A = ARDUINO_ARRAY_INDEX_FIRST ;
                                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A --;
@@ -432,11 +439,13 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_POP_LOCK( ARDUINO_ATTR_ARRAY
                             
                             } else {
                                  #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                     Serial.print("  [INCREMENT][NOTROTATE]?  ");    
+                                     //Serial.print("  [INCREMENT][NOTROTATE]?  ");    
+                                     SPFTFTFT(increment,not,rotate);
                                  #endif 
                                 if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A + 1) == ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A) {
                                          #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                             Serial.print("  2[INCREMENT][=CURRENT] [QUEUE FORCE 0] ");
+                                             //Serial.print("  2[INCREMENT][=CURRENT] [QUEUE FORCE 0] ");
+                                             SPFTFTFTFT2(increment,current,queue,force,0);
                                          #endif 
                                                  ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A = 0;
                                                   ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A = 0;
@@ -444,7 +453,8 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_POP_LOCK( ARDUINO_ATTR_ARRAY
                                 } else {
                                 
                                           #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                             Serial.print("  [POP][NEXT] ");
+                                             //Serial.print("  [POP][NEXT] ");
+                                             SPFTFT(pop,next);
                                         #endif 
                                                   ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A++;
                                                   ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A --;
@@ -457,11 +467,13 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_POP_LOCK( ARDUINO_ATTR_ARRAY
                                  
              
                                         #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                             Serial.print("  [POP][EMPTY] ");
+                                             //Serial.print("  [POP][EMPTY] ");
+                                             SPFTFT(pop,empty);
                                          #endif 
                      }
                                 #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST) || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                             Serial.print("  [POP][RETURNED["); Serial.print(ARDUINO_ARRAY_INDEX_NEXT_A); Serial.println("] ");
+                                             //Serial.print("  [POP][RETURNED["); Serial.print(ARDUINO_ARRAY_INDEX_NEXT_A); Serial.println("] ");
+                                             SPFT2(pop,ARDUINO_ARRAY_INDEX_NEXT_A);
                                          #endif 
                             return ARDUINO_ARRAY_INDEX_NEXT_A ;
                  
@@ -481,35 +493,40 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_NEXT_LOCK(
                  ARDUINO_ARRAY_INDEX_NEXT_T ARDUINO_ARRAY_INDEX_NEXT_A ;
 
                          #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST)  || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                              Serial.print("[ARDUINO_ARRAY_INDEX_NEXT_LOCK] [ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A]?  ");       
+                              //Serial.print("[ARDUINO_ARRAY_INDEX_NEXT_LOCK] [ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A]?  ");    
+                                SPFTFTFT(index,next,lock); 
                           #endif 
             if( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE) {
                         #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST)   || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]? [ERROR]  !=[ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]  ");       
+                              //Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]? [ERROR]  !=[ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]  ");
+                                SPFTFTFTFT2(index,to,init,error,-502);     
                           #endif 
             } else if(( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED)
                         or ( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A  & ARDUINO_ARRAY_ATTR_INDEX__READY_TO_QUERY)) {
                           #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)   || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__INITIALIZE][OK] if->? ");       
+                              //Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__INITIALIZE][OK] if->? ");
+                              SPFTFT2(index,init,-508);       
                           #endif 
         
             
                                 if( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__LOCK) {
                                               #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)  || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                                    Serial.print(" &[ARDUINO_ARRAY_ATTR_INDEX__LOCK] [LOCKED] [FALSE] ");       
+                                                    //Serial.print(" &[ARDUINO_ARRAY_ATTR_INDEX__LOCK] [LOCKED] [FALSE] ");   
+                                                    SPFTFTFT(index,lock,false);    
                                                 #endif 
                                                // ARDUINO_ARRAY_INDEX_NEXT_LOCK_A = NULL ; 
                                                 return 0;
                                   } else  if( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT) {
                                                #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)   || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                                    Serial.print(" =[ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT] [FALSE] ");       
+                                                    //Serial.print(" =[ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT] [FALSE] ");  
+                                                      SPFTFTFTFT(index,to,commit,false);   
                                                 #endif 
                                                  return 0;
                                                 
                                   } else  if(( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__READY_TO_QUERY)
                                         or (ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A == ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED )) {
                                                #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)   || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                                    Serial.print(" =[ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT][OK]  -> [ARDUINO_ARRAY_ATTR_QUEUE_add_distance] ");       
+                                                    Serial.print(F(" =[ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT][OK]  -> [ARDUINO_ARRAY_ATTR_QUEUE_add_distance] "));       
                                                 #endif 
                                         //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A = 
                                         //ARDUINO_ARRAY_ATTR_QUEUE_add_distance(ARDUINO_ATTR_ARRAY_A ) ;//,  ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD , ARDUINO_ARRAY_INDEX_NEXT_A, ARDUINO_ARRAY_INDEX_A) ;
@@ -518,7 +535,7 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_NEXT_LOCK(
                                          return  ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A ;
                                    } else {
                                             #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)   || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                                                    Serial.print(" =518[ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT][ERROR][ELSE]  ");       
+                                                    Serial.print(F(" =518[ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT][ERROR][ELSE]  "));       
                                             #endif 
                                             return 0;
                                    }
@@ -526,7 +543,7 @@ ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_NEXT_LOCK(
                           
             } else {
                          #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)  || defined(DEBUG_ARDUINO_ARRAY_INDEX_NEXT_LOCK)
-                              Serial.print("  ![ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED] =521[ELSE][ERROR] ");       
+                              Serial.print(F("  ![ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED] =521[ELSE][ERROR] "));       
                           #endif
                           return 0;
             }
@@ -573,7 +590,7 @@ char DISPLAY_array16_I(char message[], int count){  //to provide messages concat
         DISPLAY_array16_S.toCharArray(DISPLAY_array16_A, DISPLAY_array16_S.length());
         #ifdef DEBUG 
             if(DEBUG > 4) {
-                Serial.print("#189 DISPLAY_array16_I ") ; Serial.print(DISPLAY_array16_A); Serial.println(" ] ");
+                Serial.print(F("#189 DISPLAY_array16_I ")) ; Serial.print(DISPLAY_array16_A); Serial.println(F(" ] "));
              }
         #endif
         return DISPLAY_array16_A ;
@@ -616,7 +633,7 @@ void BYTE_SAFE_DECREMENT_TO_LIMIT(byte limit_min_with, byte &curr_value, int try
          //return limit_min_with;
          curr_value = limit_min_with ;
         }  else {
-             Serial.print(" SAFE DECR detect curr["); Serial.print(curr_value); Serial.print("] decrement[");  Serial.print(try_decrement); Serial.print("]  ");
+             Serial.print(F(" SAFE DECR detect curr[")); Serial.print(curr_value); Serial.print(F("] decrement["));  Serial.print(try_decrement); Serial.print(F("]  "));
              curr_value = (curr_value - try_decrement) ;
          }
 }
@@ -628,7 +645,7 @@ void INT_SAFE_DECREMENT_TO_LIMIT(int limit_min_with, int &curr_value, int try_de
          //return limit_min_with;
          curr_value = limit_min_with ;
         }  else {
-             Serial.print(" SAFE DECR detect curr["); Serial.print(curr_value); Serial.print("] decrement[");  Serial.print(try_decrement); Serial.print("]  ");
+             Serial.print(F(" SAFE DECR detect curr[")); Serial.print(curr_value); Serial.print(F("] decrement["));  Serial.print(try_decrement); Serial.print(F("]  "));
              curr_value = (curr_value - try_decrement) ;
          }
 }