a

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

@@ -87,6 +87,7 @@
 //#define DEBUG_QUEUE_ASSERT
 //#define DEBUG_QUEUE_WAIT 500
 #define DEBUG_STRUCT_INIT
+#define DEBUG_STORAGE_QUEUE_TEST //
 
 //#define HAS__PCINT_setup //to allow interrupts
 

SE/stuff/P5_Automation_can-dev-res/_Slave_Ports_Status_QUEUE_add_func.h

@@ -47,8 +47,38 @@ ARDUINO_FUNCT_INIT_RESULT_T _Slave_Ports_queue__add( Slave_Ports_Status_QUEUE_T*
      //ARDUINO_ARRAY_INDEX_NEXT_T Slave_Ports_Status_QUEUE_NEXT_A;
       //ARDUINO_ARRAY_INDEX_NEXT_T Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A=ARDUINO_ARRAY_INDEX_NEXT_LOCK(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A,Slave_Ports_ATTR_QUEUE_A) ; //TODOARDUINO_ARRAY_INDEX_CURRENT_T Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A =  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A ;
        //first index next
+       #if defined(DEBUG_STORAGE_QUEUE_TEST)
+        Serial.println(""); ARDUINO_ATTR_ARRAY_S__display(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+       #endif
+       
        ARDUINO_ARRAY_INDEX_NEXT_T Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A = ARDUINO_ARRAY_INDEX_NEXT_LOCK(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
       // ARDUINO_ARRAY_ATTR_QUEUE_T Slave_Ports_ATTR_QUEUE_A = ARDUINO_ARRAY_ATTR_QUEUE(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+      
+       #if defined(DEBUG_STORAGE_QUEUE_TEST)
+            Serial.print(" 54[DEBUG_STORAGE_QUEUE_TEST][ADD] ");
+            if(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__LOCK ) Serial.print(" [ERROR] [SHOULD][ARDUINO_ARRAY_ATTR_INDEX__LOCK] ");
+            ARDUINO_ATTR_ARRAY_S__display(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+            Serial.print("  ARDUINO_ARRAY_INDEX_NEXT_LOCK_A["); Serial.print(Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A);Serial.print("]  "); 
+           /* Serial.println("]  another try to lock next index [");
+                        ARDUINO_ARRAY_INDEX_NEXT_T Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A2 = ARDUINO_ARRAY_INDEX_NEXT_LOCK(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+                        Serial.println("  Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A2["); Serial.print(Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A2);Serial.print("] "); 
+                        Serial.println("");
+                        
+                        Serial.println("Now we try commit");
+                        
+                     ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A, Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A,
+                            ARDUINO_QUEUE_ELEMENT_FLAG_COMIT_LOCKED) ; //flags of records
+    
+            ARDUINO_ATTR_ARRAY_S__display(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+                 */       
+              Serial.println("EOF 54[DEBUG_STORAGE_QUEUE_TEST][ADD] ");Serial.println("]");
+            //  delay(1000);
+            //return false;
+            
+    #endif
+      
+      
+      
       if(Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A <= 0) { //ARDUINO_ARRAY_INDEX_LIMIT_QUEUE
       Serial.println("] "); Serial.print("[#41] [ERROR] [DEBUG_QUEUE] [INDEX_NEXT_A ==0??] = [");
         Serial.print(Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A) ; Serial.print("]  ");       

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

@@ -132,66 +132,25 @@ void _Slave_Ports_queue__list( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QU
      Adafruit_PWMServoDriver_T* Adafruit_PWMServoDriver_A
  ) {
  
+      
+  ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_POP_LOCK_A = ARDUINO_ARRAY_INDEX_POP_LOCK(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A);
+       #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
+        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(" ARDUINO_ARRAY_INDEX_NEXT_LOCK_A[POP_LOCK][");Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A); Serial.print("] ");
+       #endif
+
   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 ;
 
- Serial.println("#####135####NOT WORKING PEEK TODO ADD");
  
  Serial.print(" COUNT_MAX["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX_A); 
     Serial.print("] COUNT_A["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A); Serial.print("] ");
-    Serial.print("] BACK_A["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A); Serial.print("] ");
-    Serial.print("] FRONT_A["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A); Serial.println("] ");
- return false;
+  //  Serial.print("] BACK_A["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A); Serial.print("] ");
+   // Serial.print("] FRONT_A["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A); Serial.println("] ");
+    
+    
 //call      ARDUINO_ARRAY_INDEX_NEXT_LOCK
  
- 
-// Slave_Ports_ATTR_T=ARDUINO_ARRAY_INDEX_NEXT_LOCK(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A,Slave_Ports_ATTR_QUEUE_PEEK_A );
- /*
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_COUNT_MAX_A  = ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX_A   ;
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_COUNT_A = ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A    //  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ;
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_BACK_A = ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A  ;
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_FRONT_A = ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A ;
-*/
- //ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_PEEK_A = Slave_Ports_Status_QUEUE_T_INDEX_CURRENT_A ;
-// Slave_Ports_Status_QUEUE_T_INDEX_CURRENT_A =  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ;
-//DO OBSLUGI KOLEJEK 
-
-  //ARDUINO_ARRAY_INDEX_CURRENT_T Slave_Ports_Status_QUEUE_T_INDEX_CURRENT_A =  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ;
-
-     /*     
-        
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_COUNT_MAX_A     ;
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_COUNT_A =  Slave_Ports_Status_QUEUE_T_INDEX_CURRENT_A =  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ;
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_BACK_A ;
-ARDUINO_ARRAY_ATTR_T Slave_Ports_ATTR_QUEUE_FRONT_A ;
-
-
-Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A, 
-                Slave_Ports_ATTR_QUEUE_COUNT_A, Slave_Ports_ATTR_QUEUE_PEEK_A,
-                Slave_Ports_ATTR_QUEUE_BACK_A , Slave_Ports_ATTR_QUEUE_FRONT_A,
-                 ARDUINO_ARRAY_ATTR_QUEUE_ACTION_ADD | ARDUINO_ARRAY_ATTR_QUEUE_BACK
-                
-                );
- 
- */
-   //int count = _Slave_Ports_queuev.count();
-   //int _Slave_Ports_queue_pop _Slave_Ports_queuev.pop();
-  //Serial.print("#180 run _Slave_Ports_queue__POP cnt ");
-  //Serial.print(_Slave_Ports_queue_count); Serial.print(" , pop: "); Serial.println(_Slave_Ports_queue_pop);
-  /*
-        Serial.print("[AFTER INIT] [CNT= ");  Serial.print(Slave_Ports_ATTR_QUEUE_COUNT_A); Serial.print("]   ");
-        Serial.print(" [FRONT "); Serial.print(Slave_Ports_ATTR_QUEUE_BACK_A); Serial.print("]   ");
-        Serial.print(" [BACK ");  Serial.print(Slave_Ports_ATTR_QUEUE_BACK_A); Serial.print("]   ");
-        
-       
-  
- */ 
-   Serial.print("[#1] _Slave_Ports_queue__POP    COUNT_A[");
-  
-  
-  
-  
-  
-  
+   
   Serial.print("[#120] _Slave_Ports_queue__POP    COUNT_A[");
             // Serial.print(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A);
                 Serial.print("    Slave_Ports_ATTR_QUEUE_COUNT_T[");
@@ -199,10 +158,10 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
   
   
   //Serial.print([ ARDUINO_ARRAY_COUNT_A]);
-               _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A) ; 
+               _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A) ; 
    
    // if (_Slave_Ports_queue_count > 0) {
-   if(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A > 0) {
+   if(ARDUINO_ARRAY_INDEX_POP_LOCK_A > 0) {
                             /*
                              String LCDarray1 = "`Slave_Ports_queue size [";
                              LCDarray1.concat(_Slave_Ports_queue_count);
@@ -231,15 +190,15 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
 //    LCD_print(LCDarray1, LCDarray2, LCDtim / 3 ) ;
 
              // if(Slave_Ports_Status_QUEUE_A[_Slave_Ports_queue_pop].QUEUE_ID_A == 0 and
-                if(Slave_Ports_Status_QUEUE_A[ Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ].QUEUE_ID_A == 0 and
+                if(Slave_Ports_Status_QUEUE_A[ ARDUINO_ARRAY_INDEX_POP_LOCK_A ].QUEUE_ID_A == 0 and
                 //Slave_Ports_Status_QUEUE_A[_Slave_Ports_queue_pop].QUEUE_ID_A == 0 and
                 //  Slave_Ports_Status_QUEUE_A[_Slave_Ports_queue_pop].TASK_TYPE_A == 0 and
-                    Slave_Ports_Status_QUEUE_A[  Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ].TASK_TYPE_A == 0 and
+                    Slave_Ports_Status_QUEUE_A[  ARDUINO_ARRAY_INDEX_POP_LOCK_A ].TASK_TYPE_A == 0 and
                     //Slave_Ports_Status_QUEUE_A[_Slave_Ports_queue_pop].TASK_PORT_ASSOC_A == 0 and 
                     //  Slave_Ports_Status_QUEUE_A[_Slave_Ports_queue_pop].time_seq_id == 0 and 
-                    Slave_Ports_Status_QUEUE_A[ Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ].time_seq_id == 0 and
+                    Slave_Ports_Status_QUEUE_A[ ARDUINO_ARRAY_INDEX_POP_LOCK_A ].time_seq_id == 0 and
                     //    Slave_Ports_Status_QUEUE_A[_Slave_Ports_queue_pop].time_min_run == 0 ) {
-                    Slave_Ports_Status_QUEUE_A[ Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ].time_min_run == 0 ) {
+                    Slave_Ports_Status_QUEUE_A[ ARDUINO_ARRAY_INDEX_POP_LOCK_A ].time_min_run == 0 ) {
                     
                     
                /* todo
@@ -252,7 +211,7 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
                 */
                   #if defined(DEBUG)
                     // if(DEBUG > 6) {
-                                   Serial.print("#166  [DEBUG]  Error with queue [INDEX_CURR]=["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A);
+                                   Serial.print("#166  [DEBUG]  Error with queue [INDEX_CURR]=["); Serial.print(ARDUINO_ARRAY_INDEX_POP_LOCK_A);
                                    Serial.println("]  ");
                              //      }
                     #endif    
@@ -268,43 +227,43 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
                    Serial.println(LCDarray2);
             //        LCD_print(LCDarray1, LCDarray2, LCDtim / 3 ) ;
                     */
-                     if(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_min_run > millis()) {
-                            Serial.print("#182 QUEUE reassign .time_seq_id > millis()  time_seq_id[");     Serial.print( Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_seq_id); 
+                     if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_min_run > millis()) {
+                            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(millis());
-                            Serial.print("]  TASK_TYPE_A["); Serial.print(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A);
-                            Serial.print("]  Will wait() to next ["); Serial.print(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_seq_id);
-                            Serial.print("]  #["); Serial.print(Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A);  Serial.print("]  ID["); Serial.print(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].QUEUE_ID_A);  Serial.println("]  ");  
+                            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("]  ");  
                             _Slave_Ports_queue__add( Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A , 
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_PORT_ASSOC_A,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_seq_id,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_min_run,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_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,
+                                Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_seq_id,
+                                Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_min_run,
+                                Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A
                               );
                                Serial.print("[WILL DELETE REC]     millis()["); Serial.print(millis());
-                              Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]={} ; //TODO delete by func 
+                              Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ; //TODO delete by func 
 
 
                         //TODO CALL STORAGE ROUND ROBIN
             
-                     } else if(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_ttl_decrement) {
+                     } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_ttl_decrement) {
                             
-                                      Serial.print("#224 running _Slave_Ports_ttl_decrement = ");     Serial.println( Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A); Serial.println("]");     
+                                      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("]");     
                                       //#include "_Slave_Ports_ttl_decrement.h"
-                                      _Slave_Ports_ttl_decrement_POP(Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A,  Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ,  Slave_Ports_Status_A ) ;  
-                                    Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]={} ;  
+                                      _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 ) ;  
+                                    Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ;  
                                       //TODO STORAGE
-                     } else if(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_broadcast____) {
-                                      Serial.print("#337 running _Slave_Ports_broadcast = ");     Serial.println( Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A); Serial.println("]");     
+                     } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == TASK_TYPE_T_Slave_Ports_broadcast____) {
+                                      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("]");     
                                      // #include "_Slave_Ports_ttl_decrement.h"
                                      _Slave_Ports_broadcast_POP(                                     
                                                  Slave_Ports_Status_QUEUE_A, 
                                                  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,
                                                  Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A, 
-                                                 Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A, 
+                                                 ARDUINO_ARRAY_INDEX_POP_LOCK_A, 
                                                  Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A, 
                                                  Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A,
-                                                 Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A,
+                                                 ARDUINO_ARRAY_INDEX_POP_LOCK_A,
                                                  LCDtim,   
                                               Slave_Ports_Status_A ,
                                               Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A ,
@@ -324,11 +283,11 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
                                             DISPLAY_PHYSICAL_CHAR_A
                                             */
                                             ) ;
-                                      Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]={} ;    //todo storage
-                     } else if(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A == TASK_TYPE_T_DISPLAY_queue_pop________ ) {
-                       Serial.print("#212 DISPLAY TASK_TYPE_A[");     Serial.print( Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_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________ ) {
+                       Serial.print("#212 DISPLAY TASK_TYPE_A[");     Serial.print( Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A);
                              Serial.println("] ");   
-                        _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A) ;
+                        _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A) ;
                      
                             
                                // #include "_DISPLAY_queue_pop_func.h"
@@ -336,27 +295,27 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
                                                     DISPLAY__print( DISPLAY_A ,
                                                     DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
                                                     DISPLAY_PHYSICAL_CHAR_A, 
-                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_pos_seq_A,
-                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_array16_A,
-                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_TARGET_A,
-                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].time_seq_id_A,
-                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].time_min_run_A,
+                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_pos_seq_A,
+                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_array16_A,
+                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].DISPLAY_TARGET_A,
+                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].time_seq_id_A,
+                                                    DISPLAY_A[Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A].time_min_run_A,
                                                     //queue
                                                     Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,
-                                                    Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A,
-                                                    Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_PORT_ASSOC_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);
                                                                            
-                                        Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]={} ;   //todo storage
-                                        Serial.print("#201 DELETED DISPLAY TASK_TYPE_A #[");     Serial.print( Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A);
+                                        Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ;   //todo storage
+                                        Serial.print("#201 DELETED DISPLAY TASK_TYPE_A #[");     Serial.print( ARDUINO_ARRAY_INDEX_POP_LOCK_A);
                                         
                                         
-                      } else if(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A == 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[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A); Serial.println("]");     
+                      } else if(Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].TASK_TYPE_A == 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("]");     
                                       //#include "_Slave_Ports_ttl_decrement.h"
                                       _Slave_Ports_I2C_POP(
                                         //Slave_Ports_Status_QUEUE_A, _Slave_Ports_queue_pop ,  Slave_Ports_Status_A 
                                          Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,
-                                         Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ,  
+                                         ARDUINO_ARRAY_INDEX_POP_LOCK_A ,  
                                          Slave_Ports_Status_A,
                                           Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A ,
                                            //display
@@ -366,27 +325,27 @@ Slave_Ports_Status_QUEUE_STATIC_ID_COUNTER( Slave_Ports_ATTR_QUEUE_COUNT_MAX_A,
                                                  DISPLAY_pos_seq_A_NEXT, //initial set
                                                  "#233 Setting I2C" , //DISPLAY_array16_A,
                                                   DISPLAY_TARGET_ANY , //DISPLAY_TARGET_A, - setting
-                                                  Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_seq_id, 
-                                                  Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].time_min_run,
+                                                  Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_seq_id, 
+                                                  Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].time_min_run,
                                              //tasks
-                                               Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A,
-                                               Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_PORT_ASSOC_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,
                                                 Adafruit_PWMServoDriver_A
                                         ) ;  
-                                         Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]={} ;   //todo storage
+                                         Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ;   //todo storage
                      } else {
 
-                             Serial.print("$177 Error unsupported type TASK_TYPE_A[");     Serial.print( Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A);
-                             _Slave_Ports_queue_task_type_DESC(Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A) ;
+                             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);
+                             _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");     
                              _Slave_Ports_queue__add( Slave_Ports_Status_QUEUE_A,  Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_TYPE_A,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].TASK_PORT_ASSOC_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,
                                 millis(), 
                                 millis() +  ARDUINO_time_seq_id_A_INCREMENT ,
-                                Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A
+                                Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A].DISPLAY_ARDUINO_ARRAY_INDEX_A
                               );
-                              Slave_Ports_Status_QUEUE_A[Slave_Ports_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A]={} ;  
+                              Slave_Ports_Status_QUEUE_A[ARDUINO_ARRAY_INDEX_POP_LOCK_A]={} ;  
                               //TODO STORAGE
                      }
 

SE/stuff/P5_Automation_can-dev-res/_Slave_Ports_Status_QUEUE_struct.h

@@ -31,7 +31,13 @@ static Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T Slave_Ports_Status_QUEUE_
              ARDUINO_ARRAY_INDEX_LIMIT_QUEUE , 
              ARDUINO_ARRAY_INDEX_NEXT_INIT,
              ARDUINO_ARRAY_time_min_run_MIN_INIT,
-             ARDUINO_ARRAY_INDEX_time_min_run_MIN_INIT  
+             ARDUINO_ARRAY_INDEX_time_min_run_MIN_INIT,
+             ARDUINO_QUEUE_FLAG_INIT,
+             ARDUINO_ARRAY_ATTR_QUEUE_BACK_INIT,
+             ARDUINO_ARRAY_ATTR_QUEUE_COUNT_INIT, 
+             ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_INIT, 
+             ARDUINO_ARRAY_ATTR_QUEUE_FRONT_INIT ,
+             ARDUINO_ARRAY_ATTR_QUEUE_PEEK_INIT 
               }
     ;
     

SE/stuff/P5_Automation_can-dev-res/___main/__main_struct.h

@@ -127,7 +127,8 @@ typedef byte ARDUINO_QUEUE_FLAG_T  ;
 typedef ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_ELEMENT_FLAG_T ; //type to be inside array to control
 const ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_INITIAL_CORRUPT = B00000001 ; //type of empty initial array records
 const ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_COMIT_CONTEXT   = B00000010 ; //to handle this flag by functions - shows that is expected sturcture
-const ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD        = B00000100 ; //type of empty initial array records
+const ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_COMIT_LOCKED    = B00000100 ; //when locked commit
+const ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD        = B00001000 ; //type of empty initial array records
 
 
 
@@ -146,6 +147,8 @@ const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_FULL_ONLY_POP             = B1000
 typedef  ARDUINO_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T; //do obslygi kluczy
 
 
+const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_INIT      = B00000000 ; //initial state
+
 const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE    = B00000000 ; //initial state
 const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED      = B00000001 ; //initial state
 const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT        = B00000010 ; 

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

@@ -71,7 +71,7 @@ void ARDUINO_ATTR_ARRAY_S__init(  //to init attr list table[1]
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A  = ARDUINO_QUEUE_FLAG_INIT | ARDUINO_QUEUE_FLAG_A ; Serial.print(" [?78]  [ARDUINO_QUEUE_FLAG_A] ?"); 
                                                                                                                                         Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A , BIN); Serial.print("]   ");
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A = ARDUINO_ARRAY_ATTR_QUEUE_COUNT_INIT; //kolejka elementow
-                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A = ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE ;
+                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A = ARDUINO_QUEUE_FLAG_INITIALIZED ;//ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE ;
             
             if((ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_INIT ) ) {
             
@@ -168,16 +168,41 @@ void ARDUINO_ARRAY_INDEX_TABLE_S__add_void(
 
 void ARDUINO_ATTR_ARRAY_S__display(  //to init attr list table[1]
     ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A) {    
-        Serial.print("   [#139 ARRAY_S__display]   #CURRENT[");
+        Serial.println("   [#139 ARRAY_S__display]   #CURRENT[");
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A); Serial.print("]  #LAST[");
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A); Serial.print("]  #COUNT[");
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ); Serial.print("]  #LIMIT[");
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A ); Serial.print("]  #NEXT[");
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A); Serial.print("]  @time_min_run[");
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_time_min_run_MIN_A ); Serial.print("]  #time_run_#[");
-             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_time_min_run_MIN_A );Serial.print("]  #QUEUE_FLAG_A#[");
-             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A, BIN); Serial.print("]  QUEUE_BACK[");
-             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A); Serial.print("]  QUEUE_COUNT["); //ostatni zabrany element
+             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_time_min_run_MIN_A );Serial.println("] ");
+             Serial.print("]                #QUEUE_FLAG_A#["); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A, BIN);Serial.print("]  [");  
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_INIT) Serial.print(" +[INIT] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_INITIALIZED) Serial.print(" +[INITIALIZED] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_RESTRICT_INDEX) Serial.print(" +[RESTRICT_INDEX] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_CAN_OVERWRITE) Serial.print(" +[CAN_OVERWRITE] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_USE_ELEMENT_FLAG_T) Serial.print(" +[USE_ELEMENT_FLAG_T] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_CANNOT_OVERWRITE) Serial.print(" +[CANNOT_OVERWRITE] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_NOT_SPECIFIED) Serial.print(" +[NOT_SPECIFIED] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_QUEUE) Serial.print(" +[QUEUE] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_FULL_ONLY_POP) Serial.print(" +[FULL_ONLY_POP] ");
+            Serial.println("] ");
+            Serial.print("]             #INDEX_OPTIONS_A#["); 
+            Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A, BIN);  Serial.print("]  ["); 
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE) Serial.print(" +[TO_INITIALIZE] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED) Serial.print(" +[INITIALIZED] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT) Serial.print(" +[TO_COMMIT] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT) Serial.print(" +[TO_INCREMENT] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__READY_TO_QUERY) Serial.print(" +[READY_TO_QUERY] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__INCREMENTED) Serial.print(" +[INCREMENTED] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__LOCK) Serial.print(" +[LOCK] ");
+                if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__HAS_ERRORS) Serial.print(" +[HAS_ERRORS] ");
+                
+             Serial.println("] ");
+             Serial.print("]             QUEUE_BACK[");
+             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A); Serial.print("]  QUEUE_FRONT["); //ostatni zabrany element
+             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A); Serial.print("]  QUEUE_PEEK["); 
+             Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A); Serial.print("]  QUEUE_COUNT[");  //todo ostatni element zabierany
              Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A );  Serial.println("]    ");//kolejka elementow  
     }
 
@@ -243,119 +268,6 @@ void ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(  //to maintain limit and set new i
 
 
 //    ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T  
-void ARDUINO_ARRAY_ATTR_QUEUE_add_distance(
-         ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A //, 
-        //    ARDUINO_ARRAY_INDEX_NEXT_T &ARDUINO_ARRAY_INDEX_NEXT_A,
-        // ARDUINO_ARRAY_INDEX_T &ARDUINO_ARRAY_INDEX_A
-         ) {
-    //int INDEX_TO_POP ;
-    int Q1 ;
-    int Q2;
-    int BACK ;  
-    
-    
-    //boolean DIST_FROM_INDEX_CURRENT_A__rotated_to__QUEUE_BACK_A ;
-    //ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A - dlugosc kolejki
-    //ARDUINO_ARRAY_ATTR_QUEUE_BACK_A - indeks do POP
-    if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_QUEUE ) {
-                             #if   defined(DEBUG_QUEUE)
-                                       Serial.println("  ==[ ARDUINO_QUEUE_FLAG_QUEUE ]==  ");
-                            #endif 
-                if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A + 1) >= (ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A -ARDUINO_ARRAY_INDEX_FIRST )) {
-                    //size queue za duza - opcja albo 
-                        //ARDUINO_QUEUE_FLAG_CAN_OVERWRITE            
-                        if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_CAN_OVERWRITE ) {
-                            //przesuwamy wszystkie indeksy w prawo - nie powiekszajac kolejki, bo jest max
-                            #if defined(DEBUG_QUEUE)
-                             Serial.println("[#161] ARDUINO_ARRAY_ATTR_QUEUE_distance  [FLAG_CAN_OVERWRITE]");
-                            #endif 
-                             
-                                ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_basic_rotate(ARDUINO_ATTR_ARRAY_A);
-                        } else if(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_QUEUE ) {
-                        //ARDUINO_QUEUE_FLAG_CANNOT_OVERWRITE //
-                        //or todo indivual array elements ARDUINO_QUEUE_FLAG_USE_ELEMENT_FLAG_T
-                           #if  defined(DEBUG_QUEUE)
-                             Serial.print("[#161] ARDUINO_ARRAY_ATTR_QUEUE_distance  [ARDUINO_QUEUE_FLAG_QUEUE]");
-                             Serial.print(" [SIZE_MAX] [NEED OVERWRITE]  +[ARDUINO_QUEUE_FLAG_FULL_ONLY_POP]"); Serial.println("");
-                             
-                            #endif 
-                            ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A = ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A | ARDUINO_QUEUE_FLAG_FULL_ONLY_POP ;
-                            
-                        }
-                } else if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A > ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A) ) {
-                
-                
-                    Q1 =  ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A - ARDUINO_ARRAY_INDEX_FIRST ;
-                    Q2 = (  ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A - Q1 ) ;
-                    BACK =  ( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A +  ARDUINO_ARRAY_INDEX_FIRST ) - Q2 ; 
-                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A =  BACK ;
-                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A =  Q2 ;
-                
-                   /*ARDUINO_ARRAY_INDEX_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX_A = 
-                   ARDUINO_ARRAY_INDEX_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A =
-                   ARDUINO_ARRAY_INDEX_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A =
-                   ARDUINO_ARRAY_INDEX_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A =
-                   ARDUINO_ARRAY_INDEX_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A =  //TODO
-                   */
-                    
-                     #if  defined(DEBUG_QUEUE)
-                          Serial.println("[#1470] ARDUINO_ARRAY_ATTR_QUEUE_distance [USING [QUEUE_COUNT]]");
-                            Serial.println("1...........LIMIT_A........................>");
-                            Serial.println("#######(PREV)[I](NEXT).....[Q](BACK)#######>");
-                            Serial.println("|---[Q1]------|            |------[Q2]-----|");
-                            Serial.println("     Q1 = I   Q2 = (Q - Q1)         B=L-Q  ");
-                            Serial.println("|--------------------------------[BACK]     ");
-                            Serial.print(" [ ");  Serial.print(Q1);  Serial.print("]  ") ;
-                            Serial.print(" [ "); Serial.print(Q2);  Serial.print("]  ") ;
-                            Serial.print(" [ ");  Serial.print(BACK)  ;Serial.print("]  ");
-            
-                     #endif 
-                
-                
-                 } else  if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A < ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A) {
-                  
-                     Q1 = (ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A + ARDUINO_ARRAY_INDEX_FIRST) - ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ;
-                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A =  Q1 ; //TODO CHECK
-                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A =  Q1 ; //TODO CHECK
-                     #if defined(DEBUG_QUEUE)
-                          Serial.println("[#1470] ARDUINO_ARRAY_ATTR_QUEUE_distance [USING [QUEUE_COUNT]]");
-                            Serial.println("1...........LIMIT_A........................>");
-                            Serial.println(".....[Q](BACK)#########>(PREV)[I](NEXT)....");
-                            Serial.println("|--[Q1]--|                                  ");
-                            Serial.println("     Q1 = (I - Q)                           ");
-                            Serial.println("|--------------------------------[BACK]     ");
-                            Serial.print(" [ ");  Serial.print(Q1);  Serial.print("]  ") ;
-                            //Serial.print(" [ "); Serial.print(Q2);  Serial.print("]  ") ;
-                            Serial.print(" [ ");  Serial.print(BACK)  ;Serial.print("]  ");
-            
-                     #endif 
-                 } else {
-                    #if defined(DEBUG_QUEUE) || defined(DEBUG)
-                        Serial.println("[#228] ARDUINO_ARRAY_ATTR_QUEUE_distance [UERROR?]");
-                     #endif 
-                 }
-                     
-            } else {
-                            #if defined(DEBUG_QUEUE)
-                             Serial.println("  [ELSE][DEFAULT] ->RUN-> [ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate]    ");
-                            #endif
-                            
-                       
-                       //ARDUINO_ARRAY_INDEX_NEXT_A  =   
-                       ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(  //to maintain limit and set new indexes
-                                         ARDUINO_ATTR_ARRAY_A ,
-                                         //ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A,
-                                         0  //to provide index pointer to last
-                                         ) ;
-                          #if defined(DEBUG_QUEUE)
-                             Serial.println("  +[ARDUINO_ARRAY_INDEX_NEXT_A]    ");
-                            #endif
-            
-            }
-         
-     }
-
-
 
 
 void ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
@@ -365,45 +277,55 @@ void ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
           ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_A //flags of records
       ) { //when added new element call this func
       
-      #if defined(DEBUG) || defined(DEBUG_QUEUE)
+      #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
       // || DEBUG_QUEUE)
       
-        Serial.println("[  #297 ARDUINO_ATTR_ARRAY_S__commit_added_element]  [INCREMENTED]  ARDUINO_QUEUE_FLAG_A[");Serial.print(ARDUINO_QUEUE_FLAG_A,BIN); Serial.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("]   ");
       #endif
       
     
     if(ARDUINO_ARRAY_INDEX_CURRENT_A == ARDUINO_ARRAY_INDEX_CORRUPT )  {
-     #if defined(DEBUG) || defined(DEBUG_QUEUE)
+     #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
         Serial.println("[  #2398 commit_added_element]  [ARDUINO_ARRAY_INDEX_CORRUPT] ignored");
       #endif
     } else if(ARDUINO_QUEUE_ELEMENT_FLAG_A & ARDUINO_QUEUE_ELEMENT_FLAG_INITIAL_CORRUPT) {
-      #if defined(DEBUG) || defined(DEBUG_QUEUE)
+      #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
         Serial.println("[  #3338 commit_added_element]  [ARDUINO_QUEUE_ELEMENT_FLAG_INITIAL_CORRUPT] ignored");
       #endif
     } else {
         //if should index rotate
-             #if defined(DEBUG) || defined(DEBUG_QUEUE)
+             #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
                 Serial.println("[  #555 commit_added_element]  [if should index rotate]??");
               #endif
-                if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A + 1) > ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A) {
+                if((ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A + 1) >= ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A) {
                      
-                      #if defined(DEBUG) || defined(DEBUG_QUEUE)
-                              Serial.print("   +[INDEX_NEXT_rotate]   ");
+                      #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
+                              Serial.print("   +[ARDUINO_ARRAY_COUNT_A][HIT]   ");
                        #endif
-                        //should rotate
-                        ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(ARDUINO_ATTR_ARRAY_A, 
-                            //ARDUINO_QUEUE_FLAG_A 
-                            millis()); //todo element value
-                        //check if we not corrupt ARDUINO_ARRAY_ATTR_QUEUE_BACK_A
-                        ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A = ARDUINO_ARRAY_ATTR_INDEX__INCREMENTED ;
-                } else {                                        
-                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A = ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ;
-                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A = ARDUINO_ARRAY_INDEX_CURRENT_A ;
+                                              
+                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A = ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A  ;
+                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A =  ARDUINO_ARRAY_INDEX_FIRST  ;
                             ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A = ARDUINO_ARRAY_INDEX_CURRENT_A + 1 ;
-                         //   ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A = ARDUINO_QUEUE_FLAG_A ;
-                            ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A = ARDUINO_ARRAY_ATTR_INDEX__INCREMENTED ;
-                 #if defined(DEBUG) || defined(DEBUG_QUEUE)
-                        Serial.print("[ELSE][INDEX_CURRENT_A + 1 > INDEX_LIMIT_A ]   [CURRENT_A][");
+                        
+                        
+                        
+                        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)
+                                    Serial.print("+set last[PEEK_A]["); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A); Serial.print("]  ");
+                               #endif
+                        }
+                        
+                        
+
+                } else {        
+                            
+                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A = ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A  ;
+                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A =  ARDUINO_ARRAY_INDEX_FIRST  ;
+                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A = ARDUINO_ARRAY_INDEX_CURRENT_A + 1 ;
+                    
+                 #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
+                        Serial.print("433[ELSE][INDEX_CURRENT_A + 1 > INDEX_LIMIT_A ]   [CURRENT_A][");
                         Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A);
                         Serial.print("]   INDEX_CURRENT_A[");
                         Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A);
@@ -411,12 +333,23 @@ void ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
                    #endif
                 
                 
-                
                 }
             
-            
-    
-        ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A++ ;
+                        ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A = ARDUINO_ARRAY_ATTR_INDEX__READY_TO_QUERY ;
+                        ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A = ARDUINO_ARRAY_INDEX_CURRENT_A ;
+                        ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ++;
+                        ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A ++;
+                        
+                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)
+                        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("]  ");
+                   #endif
+                
+                   
+                }
+                        
     }
      
     
@@ -443,6 +376,37 @@ ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT(
 }
 
 
+ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_POP_LOCK( ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_A){
+                 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)
+                              Serial.print("  [ARDUINO_ARRAY_INDEX_POP_LOCK]?  ");       
+                          #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)
+                              Serial.print("  [INCREMENT][PEEK]  ");    
+                          #endif 
+                          
+                    ARDUINO_ARRAY_INDEX_NEXT_A =  ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ;
+                        if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A + 1 >= ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A) {
+                            if(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A == ARDUINO_ARRAY_INDEX_FIRST) {
+                                      Serial.print("  [PEEK NO MORE] [DECREASE QUEUE]  "); 
+                                      ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A = 0;
+                                      ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A --;
+                                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A --;
+                            }
+                        } else {
+                                 Serial.print("  [PEEK NEXT] [DECREASE QUEUE]  "); 
+                                    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A++;
+                                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A --;
+                                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A --;
+                        }
+                    
+                    return ARDUINO_ARRAY_INDEX_NEXT_A ;
+                 }
+                 
+    }
+
+
 ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ARDUINO_ARRAY_INDEX_NEXT_LOCK( 
         ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_A//, 
         //ARDUINO_ARRAY_INDEX_T &ARDUINO_ARRAY_INDEX_A //,
@@ -455,45 +419,52 @@ 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)
-                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A]?  ");       
+                         #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST)
+                              Serial.print("[ARDUINO_ARRAY_INDEX_NEXT_LOCK] [ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A]?  ");       
                           #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)
-                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]?  ");       
+                        #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT) || defined(DEBUG_STORAGE_QUEUE_TEST)
+                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]? [ERROR]  !=[ARDUINO_ARRAY_ATTR_INDEX__TO_INITIALIZE]  ");       
                           #endif 
             } else if( 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)
-                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__INITIALIZE][OK] ");       
+                          #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
+                              Serial.print(" [ARDUINO_ARRAY_ATTR_INDEX__INITIALIZE][OK] if->? ");       
                           #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)
+                                              #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
                                                     Serial.print(" &[ARDUINO_ARRAY_ATTR_INDEX__LOCK] [LOCKED] [FALSE] ");       
                                                 #endif 
                                                // ARDUINO_ARRAY_INDEX_NEXT_LOCK_A = NULL ; 
                                                 return false;
                                   } 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)
+                                               #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
                                                     Serial.print(" =[ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT] [FALSE] ");       
                                                 #endif 
                                                  return false;
                                                 
-                                  } else  if( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT) {
-                                               #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)
+                                  } else  if(( ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A & ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT)
+                                        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)
                                                     Serial.print(" =[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) ;
+                                        //ARDUINO_ARRAY_ATTR_QUEUE_add_distance(ARDUINO_ATTR_ARRAY_A ) ;//,  ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD , ARDUINO_ARRAY_INDEX_NEXT_A, ARDUINO_ARRAY_INDEX_A) ;
+                                        
                                         ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A =  ARDUINO_ARRAY_ATTR_INDEX__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)
+                                                    Serial.print(" =518[ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT][ERROR][ELSE]  ");       
+                                            #endif 
+                                            return false;
                                    }
                     
                           
             } else {
-                         #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)
-                              Serial.print(" =[ELSE][ERROR] ");       
+                         #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)  || defined(DEBUG_STORAGE_QUEUE_TEST)
+                              Serial.print("  ![ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED] =521[ELSE][ERROR] ");       
                           #endif
                           return false;
             }