a

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

@@ -1,19 +1,19 @@
 
 ARDUINO_FUNCT_INIT_RESULT_T _Slave_Ports_queue__add( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A, 
      Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A,
-TASK_TYPE_T TASK_TYPE_A,
-TASK_PORT_ASSOC_T TASK_PORT_ASSOC_A, //
-long time_seq_id, 
-long time_min_run , //, 
-ARDUINO_ARRAY_INDEX_T DISPLAY_ARDUINO_ARRAY_INDEX_A //optionally
-//int _Slave_Ports_queue_peek , int _Slave_Ports_queue_push , int _Slave_Ports_queue_peek_new
-) {
-  Serial.println(".");
-      Serial.print("#152 _Slave_Ports_queue__add  TASK_TYPE_A[");
-       Serial.print(TASK_TYPE_A); Serial.print(" [");  _Slave_Ports_queue_task_type_DESC(TASK_TYPE_A); Serial.print("]  cur_peek:[");
-       
-       
-  
+    TASK_TYPE_T TASK_TYPE_A,
+    TASK_PORT_ASSOC_T TASK_PORT_ASSOC_A, //
+    long time_seq_id, 
+    long time_min_run , //, 
+    ARDUINO_ARRAY_INDEX_T DISPLAY_ARDUINO_ARRAY_INDEX_A //optionally
+    //int _Slave_Ports_queue_peek , int _Slave_Ports_queue_push , int _Slave_Ports_queue_peek_new
+    ) {
+      Serial.println(".");
+          Serial.print("#152 _Slave_Ports_queue__add  TASK_TYPE_A[");
+           Serial.print(TASK_TYPE_A); Serial.print(" [");  _Slave_Ports_queue_task_type_DESC(TASK_TYPE_A); Serial.print("]  cur_peek:[");
+           
+           
+      
       
   
         
@@ -43,8 +43,12 @@ ARDUINO_ARRAY_INDEX_T DISPLAY_ARDUINO_ARRAY_INDEX_A //optionally
       
       //CONTROLLING ARR SIZE
       //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_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 ;
-
+      
+     ARDUINO_ARRAY_INDEX_NEXT_T Slave_Ports_Status_QUEUE_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
+       ARDUINO_ARRAY_INDEX_NEXT_T ARDUINO_ARRAY_INDEX_NEXT_LOCK(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A, Slave_Ports_Status_QUEUE_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(Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A == ARDUINO_ARRAY_INDEX_LIMIT_QUEUE) {
       Serial.println("] "); Serial.print("[#41] [ERROR] [DEBUG_QUEUE] [LIMIT HIT]  [ARDUINO_ARRAY_INDEX_LIMIT_QUEUE] = [");
       Serial.print(ARDUINO_ARRAY_INDEX_LIMIT_QUEUE) ; Serial.print("]  ");
@@ -96,7 +100,8 @@ ARDUINO_ARRAY_INDEX_T DISPLAY_ARDUINO_ARRAY_INDEX_A //optionally
       Slave_Ports_Status_QUEUE_A[Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A].DISPLAY_ARDUINO_ARRAY_INDEX_A = DISPLAY_ARDUINO_ARRAY_INDEX_A ;
       //ARDUINO_ATTR_ARRAY_S__commit_added_element(Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A, Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A ) ;
       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_FLAG_QUEUE,ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD  ) ;
+      //ARDUINO_QUEUE_FLAG_QUEUE,
+      ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD  ) ;
        Serial.print("  new QUEUE_ID_A["); Serial.print(Slave_Ports_Status_QUEUE_A[Slave_Ports_Status_QUEUE_T_INDEX_NEXT_A].QUEUE_ID_A ); Serial.println("]    ");
         
  return true ;

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

@@ -2,8 +2,8 @@
   
 
 void _Slave_Ports_queue__INIT( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A, 
-Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A
-) {
+    Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A
+    ) {
                 #if defined(DEBUG_STRUCT_INIT)
                   Serial.print("#7AA _Slave_Ports_queue__INIT [FLAG][");
                                 Serial.print(ARDUINO_QUEUE_FLAG_QUEUE,BIN);Serial.print("] + [ ");
@@ -57,10 +57,10 @@ Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDU
 
 //Queue<_Slave_Ports_queueT> _Slave_Ports_queue = Queue<_Slave_Ports_queueT>(5);
 void _Slave_Ports_queue__list( Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A,
-Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A
-) {
-  int i;
-    Serial.println("#100 _Slave_Ports_queue__list Slave_Ports_Status_QUEUE_A): ");
+    Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A
+    ) {
+      int i;
+        Serial.println("#100 _Slave_Ports_queue__list Slave_Ports_Status_QUEUE_A): ");
     
     
     #if defined(DEBUG) || defined(DEBUG_QUEUE)
@@ -132,15 +132,18 @@ Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_QUEUE_T_ARDU
  ) {
  
  
-         
+ Serial.println("#####135####NOT WORKING PEEK TODO ADD");
+ return false;
+//call      ARDUINO_ARRAY_INDEX_NEXT_LOCK
  
- 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 ;
+ ARDUINO_ARRAY_ATTR_QUEUE_T Slave_Ports_ATTR_QUEUE_A = ARDUINO_ARRAY_ATTR_QUEUE(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 ;
  
+// 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_T Slave_Ports_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_T Slave_Ports_ATTR_QUEUE_FRONT_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 ;

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

@@ -90,24 +90,22 @@ struct ARDUINO_ARRAY_ATTR_QUEUE_S {
     ARDUINO_ARRAY_ATTR_QUEUE_PEEK_T ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ;
     ARDUINO_ARRAY_ATTR_QUEUE_BACK_T ARDUINO_ARRAY_ATTR_QUEUE_BACK_A ;
     ARDUINO_ARRAY_ATTR_QUEUE_FRONT_T ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A;
-    
 };
 
-typedef struct ARDUINO_ARRAY_ATTR_QUEUE_S ARDUINO_ARRAY_ATTR_QUEUE_T ;
-
-/*
-typedef ARDUINO_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T; //     [#109 ELSE] 100100]
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_ACTION_GET = B00000001 ;
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_ACTION_SET = B00000010 ;
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_ACTION_ADD = B00000100 ; //add back == pop
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX  = B00001000 ;
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_COUNT      = B00010000 ;
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_PEEK       = B00100000 ; //
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_FRONT      = B01000000 ; //newest set+read(add)
-const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_BACK       = B10000000 ;//add back == pop
-
-
-*/
+    
+    /*
+    typedef ARDUINO_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T; //     [#109 ELSE] 100100]
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_ACTION_GET = B00000001 ;
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_ACTION_SET = B00000010 ;
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_ACTION_ADD = B00000100 ; //add back == pop
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX  = B00001000 ;
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_COUNT      = B00010000 ;
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_PEEK       = B00100000 ; //
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_FRONT      = B01000000 ; //newest set+read(add)
+    const ARDUINO_ARRAY_ATTR_QUEUE_OPTIONS_T ARDUINO_ARRAY_ATTR_QUEUE_BACK       = B10000000 ;//add back == pop
+    
+    
+    */
  
 typedef struct ARDUINO_ARRAY_ATTR_QUEUE_S ARDUINO_ARRAY_ATTR_QUEUE_T ;
 
@@ -133,7 +131,8 @@ const ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_STANDARD        =
 
 
 
-const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_INIT                      = B00000001 ;  //just to init
+const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_INIT                      = B00000000 ;  //just to init
+const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_INITIALIZED               = B00000001 ;  //
 const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_RESTRICT_INDEX            = B00000010 ;  //no loose index changes
 const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_CAN_OVERWRITE             = B00000100 ; //data can be overwrited
 const ARDUINO_QUEUE_FLAG_T  ARDUINO_QUEUE_FLAG_USE_ELEMENT_FLAG_T        = B00001000 ; //delete order etc use ARDUINO_QUEUE_ELEMENT_FLAG_T in childs
@@ -145,13 +144,19 @@ 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__TO_INITIALIZE    = B00000001 ; //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 ; 
 const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__TO_INCREMENT     = B00000100 ; 
 const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__READY_TO_QUERY   = B00001000 ; 
-const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__QUERY_LOCKED     = B00010000 ; 
+const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__LOCK             = B00010000 ;  //use  typedef ARDUINO_ARRAY_INDEX_NEXT_T ARDUINO_ARRAY_INDEX_NEXT_LOCK_A
+
 const ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T ARDUINO_ARRAY_ATTR_INDEX__HAS_ERRORS       = B00100000 ; 
 
+ typedef ARDUINO_ARRAY_INDEX_NEXT_T ARDUINO_ARRAY_INDEX_NEXT_LOCK_T ;
+
 
 struct ARDUINO_ATTR_ARRAY_S {
     ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT_A ;

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

@@ -2,13 +2,13 @@
 #include <limits.h>
 
 void ARDUINO_ARRAY_INDEX_TABLE__SYNC_CURRENT( //when added to main table - do it
-//MAIN_TABLE_T, MAIN_TABLE_A,
-//optional ARDUINO_ARRAY_ASSOC_TABLE_S ARDUINO_ARRAY_ASSOC_TABLE_A,
-ARDUINO_ARRAY_INDEX_TABLE_S* ARDUINO_ARRAY_INDEX_TABLE_A,
-ARDUINO_ATTR_ARRAY_S* ARDUINO_ATTR_ARRAY_A
-//ASSOC TABLE
-
-) {
+    //MAIN_TABLE_T, MAIN_TABLE_A,
+    //optional ARDUINO_ARRAY_ASSOC_TABLE_S ARDUINO_ARRAY_ASSOC_TABLE_A,
+    ARDUINO_ARRAY_INDEX_TABLE_S* ARDUINO_ARRAY_INDEX_TABLE_A,
+    ARDUINO_ATTR_ARRAY_S* ARDUINO_ATTR_ARRAY_A
+    //ASSOC TABLE
+    
+    ) {
 
 
 }
@@ -20,7 +20,7 @@ void ARDUINO_ARRAY_ASSOC_TABLE_commit_added_element(
     ARDUINO_ARRAY_ASSOC_TABLE_S* ARDUINO_ARRAY_ASSOC_TABLE_A,
     ARDUINO_ARRAY_INDEX_T* ARDUINO_ARRAY_INDEX_A,
     ARDUINO_ARRAY_PRIMARY_KET_T ARDUINO_ARRAY_PRIMARY_KET_A
-) {
+    ) {
  
     int i = ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ;
 
@@ -33,7 +33,7 @@ void ARDUINO_ARRAY_ASSOC_TABLE_commit_added_element(
 void ARDUINO_ATTR_ARRAY_S__commit_added_element(
     ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_A , 
     ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT_A //current index,
-) { //when added new element call this func
+    ) { //when added new element call this func
     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_NEXT_A = ARDUINO_ARRAY_INDEX_CURRENT_A + 1 ;
@@ -52,13 +52,11 @@ void ARDUINO_ATTR_ARRAY_S__init(  //to init attr list table[1]
     ARDUINO_ARRAY_INDEX_LIMIT_T ARDUINO_ARRAY_INDEX_LIMIT_A ,//current limit table
     ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A
     ) {
-    
-            if(not(ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_INIT)) {
+            
                          
                          #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)
-                              Serial.print("[#89 ] ARDUINO_ATTR_ARRAY_S__init [ARDUINO_QUEUE_FLAG_INIT["); Serial.print(ARDUINO_QUEUE_FLAG_A, BIN) ; Serial.println("]    ");
+                              Serial.println("[#89 ] ARDUINO_ATTR_ARRAY_S__init  ");     Serial.print("]   ARDUINO_QUEUE_FLAG_A[ ") ;  Serial.print(ARDUINO_QUEUE_FLAG_A, BIN) ;      Serial.print("]   A&B [ ") ; Serial.print(ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_INIT, BIN) ;   Serial.print("]  B & A [ ") ; Serial.print( ARDUINO_QUEUE_FLAG_INIT  & ARDUINO_QUEUE_FLAG_A  ,   BIN) ;  Serial.println(" ]  ") ; 
                           #endif 
-            
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A = ARDUINO_ARRAY_INDEX_CURRENT_INIT ;
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A = ARDUINO_ARRAY_INDEX_LAST_INIT ;
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A = ARDUINO_ARRAY_COUNT_T_INIT ;
@@ -67,17 +65,42 @@ void ARDUINO_ATTR_ARRAY_S__init(  //to init attr list table[1]
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_time_min_run_MIN_A = ARDUINO_ARRAY_time_min_run_MIN_INIT ;
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_time_min_run_MIN_A = ARDUINO_ARRAY_INDEX_time_min_run_MIN_INIT ;  
                     ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A  = ARDUINO_ARRAY_ATTR_QUEUE_BACK_INIT ;
-                    ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A  = ARDUINO_QUEUE_FLAG_INIT ;
-             }  else {
-             
-                   #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)
-                              Serial.print("[#89 74] else ARDUINO_ATTR_ARRAY_S__init [ARDUINO_QUEUE_FLAG_INIT] ["); Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A, BIN) ; Serial.println("]  ");
+                    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 ;
+            
+            if((ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A & ARDUINO_QUEUE_FLAG_INIT ) ) {
+            
+                        #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)
+                              Serial.print(" [ERROR]  [HAS[ARDUINO_QUEUE_FLAG_INIT]]");        
                           #endif 
-             
-             }
+                      
+                      
+                      
+            } else {
+            
+            }
+            
+                 
     }
 
 
+
+void ARDUINO_ATTR_ARRAY_S__init_complete(ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A  , ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT_A ) {//
+
+    ARDUINO_ATTR_ARRAY_A.ARDUINO_QUEUE_FLAG_A = ARDUINO_QUEUE_FLAG_INITIALIZED  ;
+    ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A =   ARDUINO_ARRAY_ATTR_INDEX__INITIALIZED ;
+    //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_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A ;
+    //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A
+    ARDUINO_ATTR_ARRAY_S__commit_added_element(ARDUINO_ATTR_ARRAY_A , ARDUINO_ARRAY_INDEX_CURRENT_A ) ;
+//first init, add value, then complete
+
+}
+
+
+
 void ARDUINO_ARRAY_INDEX_TABLE_S__init( //to init table INDEX
     ARDUINO_ARRAY_INDEX_TABLE_T* ARDUINO_ARRAY_INDEX_TABLE_A,
     ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A,
@@ -98,7 +121,7 @@ void ARDUINO_ARRAY_INDEX_TABLE_S__init( //to init table INDEX
                 }
     }
 
-ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_TABLE_S__add( //ADD SOME INT ELEMENT OF ARDUINO_ARRAY_INDEX_A
+    ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_TABLE_S__add( //ADD SOME INT ELEMENT OF ARDUINO_ARRAY_INDEX_A
     ARDUINO_ARRAY_INDEX_TABLE_T* ARDUINO_ARRAY_INDEX_TABLE_A,
     ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A,
     int ARDUINO_ARRAY_INDEX_A //ARDUINO_ARRAY_INDEX_T 
@@ -122,7 +145,7 @@ ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_TABLE_S__add( //ADD SOME INT E
                  #if defined(DISABLE_LOOP) || defined(DEBUG)
                  Serial.print(ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A); Serial.println("]  [");
                  #endif 
-}
+    }
 
 
 void ARDUINO_ARRAY_INDEX_TABLE_S__add_void(
@@ -141,8 +164,7 @@ 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
-    ) {    
+    ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A) {    
         Serial.print("   [#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[");
@@ -172,12 +194,12 @@ void ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_basic_rotate(ARDUINO_ATTR_ARRAY_T &ARDUINO
         ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A = ARDUINO_ARRAY_INDEX_FIRST ;
     } else ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A ++ ;    
     
-}
+    }
 
 
-void ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(  //to maintain limit and set new indexes
+ARDUINO_ARRAY_INDEX_NEXT_T ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(  //to maintain limit and set new indexes
     ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A ,
-    ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A,
+   // ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A, bez semnsiu fagi
     ARDUINO_ARRAY_time_min_run_MIN_T ARDUINO_ARRAY_time_min_run_MIN_A  //to provide index pointer to last
     ) {    
         Serial.print("   [#156 ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate]   #CURRENT[");
@@ -195,7 +217,7 @@ void ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(  //to maintain limit and set new i
              //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A  = ARDUINO_ARRAY_INDEX_FIRST ;
              //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A //NOT CHANGED
              //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A// NOT CHANGED
-             ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A = ARDUINO_ARRAY_INDEX_FIRST ;
+          //   ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A = ARDUINO_ARRAY_INDEX_FIRST ;
              //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_time_min_run_MIN_A
              //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_time_min_run_MIN_A
             //ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A ;
@@ -205,18 +227,22 @@ void ARDUINO_ATTR_ARRAY_S__INDEX_NEXT_rotate(  //to maintain limit and set new i
 
          
          //validate if ARDUINO_ARRAY_ATTR_QUEUE_BACK_A nie nachodzi
+            return ARDUINO_ARRAY_INDEX_FIRST ;
    
-   
-    }
+     }
 
 
 
 
 
 
-void ARDUINO_ARRAY_ATTR_QUEUE_add_distance(ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_ARRAY_A ,ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A 
- //usable to check if not chanmged?
- ) {
+
+
+
+ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T  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;
@@ -226,75 +252,100 @@ void ARDUINO_ARRAY_ATTR_QUEUE_add_distance(ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_AR
     //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_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
-                #ifdef 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 ;
+    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_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 ;
+                     
+                     #ifd 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
+            
             }
-    } 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 ;
-    
-       
-         #ifdef 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 ;
          
-         #ifdef 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 
      }
-         
-      
-         
-}
 
 
 
@@ -302,7 +353,7 @@ void ARDUINO_ARRAY_ATTR_QUEUE_add_distance(ARDUINO_ATTR_ARRAY_T &ARDUINO_ATTR_AR
 void ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
           ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_A , 
           ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT_A, //current index,
-          ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A  ,
+      //    ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A  , bez sensu - opcjonalbnei dla rekoru
           ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_A //flags of records
       ) { //when added new element call this func
       
@@ -368,20 +419,90 @@ void ARDUINO_ATTR_ARRAY_S__commit_added_element_QUEUE(
     
 }
 
+ARDUINO_ARRAY_ATTR_QUEUE_T ARDUINO_ARRAY_ATTR_QUEUE(
+ ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_A
+ ) {
+    /* ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX_T ARDUINO_ARRAY_ATTR_QUEUE_COUNT_MAX_A;
+         ARDUINO_ARRAY_ATTR_QUEUE_COUNT_T ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A ;
+         ARDUINO_ARRAY_ATTR_QUEUE_PEEK_T ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A ;
+         ARDUINO_ARRAY_ATTR_QUEUE_BACK_T ARDUINO_ARRAY_ATTR_QUEUE_BACK_A ;
+         ARDUINO_ARRAY_ATTR_QUEUE_FRONT_T ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A;*/
+        // ARDUINO_ARRAY_ATTR_QUEUE_T ARDUINO_ARRAY_ATTR_QUEUE_A =
+        // ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_COUNT_A = 
+        // ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_PEEK_A =
+        // ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_BACK_A
+        // ARDUINO_ARRAY_ATTR_QUEUE_A.ARDUINO_ARRAY_ATTR_QUEUE_FRONT_A
+}
 
 
-/*
 
 
-void AARDUINO_ARRAY_ATTR_INDEX__LOCK(
-          ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_A , 
-          ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT_A, //current index,
-          ARDUINO_QUEUE_FLAG_T ARDUINO_QUEUE_FLAG_A  ,
-          ARDUINO_QUEUE_ELEMENT_FLAG_T ARDUINO_QUEUE_ELEMENT_FLAG_A //flags of records
-      ) { //when added new element call this func
-     }     
+ARDUINO_ARRAY_INDEX_CURRENT_T ARDUINO_ARRAY_INDEX_CURRENT(
+       ARDUINO_ATTR_ARRAY_S &ARDUINO_ATTR_ARRAY_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 //,
+        //ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_T &ARDUINO_ARRAY_ATTR_INDEX_OPTIONS_A
+        //ARDUINO_ARRAY_INDEX_NEXT_T &ARDUINO_ARRAY_INDEX_NEXT_LOCK_A,
+        //Slave_Ports_ATTR_QUEUE_COUNT_MAX_A
+        //Slave_Ports_ATTR_QUEUE_COUNT_A
+        //Slave_Ports_ATTR_QUEUE_BACK_A
+        //Slave_Ports_ATTR_QUEUE_FRONT_A
+        ){
+                 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]?  ");       
+                          #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]?  ");       
+                          #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] ");       
+                          #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)
+                                                    Serial.print(" &[ARDUINO_ARRAY_ATTR_INDEX__LOCK] [LOCKED]  ");       
+                                                #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)
+                                                    Serial.print(" =[ARDUINO_ARRAY_ATTR_INDEX__TO_COMMIT][OK] ");       
+                                                #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)
+                                                    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) ;
+                                          
+                                   }
+                    
+                          
+            } else {
+                         #if defined(DEBUG) || defined(DISABLE_LOOP) || defined(DEBUG_QUEUE) || defined(DEBUG_STRUCT_INIT)
+                              Serial.print(" =[ELSE][ERROR] ");       
+                          #endif
+                          return false;
+            }
+      
+      
+         
+
+       }
+
 
 /*
 void ARDUINO_ARRAY_COUNT(