a

SE/stuff/P5_Automation_can-dev-res/_Slave_Ports_Status_func.bakh.h

@@ -0,0 +1,207 @@
+
+ void Slave_Ports_Status_add_port(
+ Slave_Ports_Status_T* Slave_Ports_Status_A , 
+ Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A,
+  Slave_Ports_Status_T_ARDUINO_ARRAY_INDEX_TABLE_T*            Slave_Ports_Status_T_ARDUINO_ARRAY_INDEX_TABLE_A,
+  Slave_Ports_Status_T_ARDUINO_ARRAY_INDEX_T_TO_DELETE_T*      Slave_Ports_Status_T_ARDUINO_ARRAY_INDEX_T_TO_DELETE_A,
+  Slave_Ports_Status_T_ARDUINO_ARRAY_ASSOC_TABLE_S_Port_ID_T*  Slave_Ports_Status_T_ARDUINO_ARRAY_ASSOC_TABLE_S_Port_ID_A,
+                int  Port_ID,
+                int  _Slave_ID,
+                PortTypes_T  PortTypes,
+                int  Address,
+                int  LocalPort,
+                Exp_state_T  Exp_state,
+                Exp_state_ttl_T  Exp_state_ttl,
+                Broadcast_state_T  Broadcast_state,
+                int I2C_port,
+                //int I2C_driver
+                I2C_driver_T I2C_driver, 
+                IS_Local_T IS_Local_A
+                )
+{
+
+                                       #if defined(DEBUG)
+                                                     Serial.print("#2444 Slave_Ports_Status_add_port[DEBUG] # BEFORE COUNT["); Serial.print(Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A);
+                                                      Serial.print("] INDEX_LAST["); Serial.print( Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A);
+                                                      Serial.print("] INDEX_CURRENT["); Serial.print( Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A);
+                                                      Serial.print("] NEXT_A["); Serial.print( Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A);
+                                                     Serial.println("]  ");
+                                      #endif   
+
+        //int i = Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ;
+        int i = Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A ;
+        //if(Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A == 0) {
+          if(i == ARDUINO_ARRAY_INDEX_CORRUPT) {
+               
+                // Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ++;
+                          Slave_Ports_Status_A[i].Port_ID=0x00;
+                          Slave_Ports_Status_A[i]._Slave_ID=0x00;
+                          Slave_Ports_Status_A[i].PortTypes=0x00;
+                          Slave_Ports_Status_A[i].Address=0x00;
+                          Slave_Ports_Status_A[i].LocalPort=0x00;
+                          Slave_Ports_Status_A[i].Exp_state=0x00;
+                          Slave_Ports_Status_A[i].Exp_state_ttl=0x00;
+                          Slave_Ports_Status_A[i].Broadcast_state=0x00;
+                          Slave_Ports_Status_A[i].I2C_port=0x00;
+                          Slave_Ports_Status_A[i].I2C_driver=0x00;
+                          Slave_Ports_Status_A[i].IS_Local_A=IS_Local_FALSE;
+                
+                
+                ARDUINO_ATTR_ARRAY_S__commit_added_element(
+                          Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A , 
+                         i); //Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A
+                
+                //ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A
+                                
+                 //Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ++;   
+    }
+      i = Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A ;
+    
+    Slave_Ports_Status_A[i].Port_ID = Port_ID ;
+    Slave_Ports_Status_A[i]._Slave_ID = _Slave_ID ;
+    Slave_Ports_Status_A[i].PortTypes = PortTypes ;
+    Slave_Ports_Status_A[i].Address = Address ;
+    Slave_Ports_Status_A[i].LocalPort = LocalPort ;
+    Slave_Ports_Status_A[i].Exp_state = Exp_state ;
+    Slave_Ports_Status_A[i].Exp_state_ttl = Exp_state_ttl ;
+    Slave_Ports_Status_A[i].Broadcast_state = Broadcast_state ;
+    Slave_Ports_Status_A[i].I2C_port = I2C_port ;
+    Slave_Ports_Status_A[i].I2C_driver = I2C_driver ;
+    Slave_Ports_Status_A[i].IS_Local_A = IS_Local_A;
+  //  Slave_Ports_Status_A[Slave_Ports_Status_T_ARDUINO_ARRAY_COUNT_A + 1].I2C_driver = I2C_driver_F(I2C_driver) ;
+            ARDUINO_ATTR_ARRAY_S__commit_added_element(
+                          Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A , 
+                          i);//Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A
+   
+  
+}
+
+
+ void Slave_Ports_Status__DISPLAY_TARGET(
+        Slave_Ports_Status_T* Slave_Ports_Status_A ,
+        Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_T &Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A,
+        Port_ID_T  Port_ID ,
+        //display
+        DISPLAY_T* DISPLAY_A ,
+        DISPLAY_T_ARDUINO_ATTR_ARRAY_T &DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+        DISPLAY_PHYSICAL_CHAR_T &DISPLAY_PHYSICAL_CHAR_A, 
+            DISPLAY_pos_seq_T DISPLAY_pos_seq_A,
+            DISPLAY_array16_T DISPLAY_array16_A,
+            DISPLAY_TARGET_T DISPLAY_TARGET_A,
+            time_seq_id_T time_seq_id_A,
+            time_min_run_T time_min_run_A
+        //queue
+        ,Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A,
+        //tasks
+        TASK_TYPE_T TASK_TYPE_A,
+        TASK_PORT_ASSOC_T TASK_PORT_ASSOC_A
+  )
+   {
+   
+   
+   
+                #if defined(DEBUG)
+                     if(DEBUG > 6) {
+                                   Serial.print("#72 Port_Dspl[DEBUG] #COUNT["); Serial.print(Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A);
+                                    Serial.print("] INDEX_LAST["); Serial.print( Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A);
+                                    Serial.print("] INDEX_CURRENT["); Serial.print( Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A);
+                                    Serial.print("] NEXT_A["); Serial.print( Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A);
+                                    
+                                    
+                                    
+                                    Serial.print("]   XM["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A);
+                                    Serial.print("] YM["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_Y_CHARS_A);
+                                    Serial.print("] YC["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A);
+                                    Serial.print("] YF["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A);
+                                   Serial.println("]  ");
+                                  }
+                    #endif    
+   
+        String message_init = "" ;
+        DISPLAY_array16_T  DISPLAY_array16_AAT ;
+       // message_init.concat(DISPLAY_array16_A);
+        message_init.concat(" #C:");
+        message_init = message_init +  Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A ;
+        message_init = DISPLAY_array16_A + message_init ;
+        //message_init.concat(Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A , INT );
+        message_init.concat("     ");
+        message_init.toCharArray(DISPLAY_array16_AAT, message_init.length());
+        
+        String message ;
+        String message2 ;
+             DISPLAY__print(
+                          DISPLAY_A ,
+                          DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+                          DISPLAY_PHYSICAL_CHAR_A, 
+                           DISPLAY_pos_seq_A,
+                            DISPLAY_array16_AAT,
+                            DISPLAY_TARGET_A,
+                           time_seq_id_A,
+                           time_min_run_A
+                          //queue
+                        , Slave_Ports_Status_QUEUE_A,
+                         TASK_TYPE_A,
+                         TASK_PORT_ASSOC_A
+                        
+                          ); 
+        int i;
+        for(i=ARDUINO_ARRAY_INDEX_FIRST ; i <= Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A; i++) {//
+           DISPLAY_array16_T  DISPLAY_array16_AA="" ;
+           DISPLAY_array16_T  DISPLAY_array16_AB="" ;
+        
+            if(Slave_Ports_Status_A[i].Port_ID > 0) {
+            
+                #if defined(DEBUG)
+                            Serial.print("#68 Port_Dspl[DEBUG]  i "); Serial.print(i);
+                            Serial.println("]  ");
+                    #endif    
+                  message = "";
+                 message.concat(":")  ; 
+                 message.concat(i);
+                 message.concat("#");
+                 message.concat(Slave_Ports_Status_A[i].Port_ID )  ; 
+                 message.concat(" ");
+                 // message.toCharArray(DISPLAY_array16_AA, message.length());
+               /*   DISPLAY__print(
+                   DISPLAY_A ,
+                   DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+                   DISPLAY_PHYSICAL_CHAR_A, 
+                    DISPLAY_pos_seq_A,
+                     DISPLAY_array16_AA,
+                     DISPLAY_TARGET_A,
+                    time_seq_id_A,
+                    time_min_run_A
+                   ); 
+                   delay(100);
+                  // DISPLAY_array16_AA = 0 ;*/
+                   message2 = message  ; message2.concat("E:");
+                 message2.concat(Slave_Ports_Status_A[i].Exp_state )  ;
+                 message2.concat(" T:");
+                 message2.concat(Slave_Ports_Status_A[i].Exp_state_ttl )  ;
+                 message2.concat(" B:");
+                 message2.concat(Slave_Ports_Status_A[i].Broadcast_state )  ;
+                 //message2.concat(" ");
+                 message2.toCharArray(DISPLAY_array16_AB, message2.length());             
+                
+                 DISPLAY__print(
+                   DISPLAY_A ,
+                   DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+                   DISPLAY_PHYSICAL_CHAR_A, 
+                    DISPLAY_pos_seq_A,
+                     DISPLAY_array16_AB,
+                     DISPLAY_TARGET_A,
+                    time_seq_id_A,
+                    time_min_run_A
+                     //queue
+                          , Slave_Ports_Status_QUEUE_A,
+                            TASK_TYPE_A,
+                            TASK_PORT_ASSOC_A
+                   ); 
+              // delay(100);
+            }
+        }
+   
+   }  
+   
+   
+ 

SE/stuff/P5_Automation_can-dev-res/_bak/TPQxxx.xxhxxx

@@ -0,0 +1,57 @@
+#ifndef TPQ_H
+#define TPQ_H
+
+#include <Arduino.h>
+
+template<class TP>
+class TPQ {
+  private:
+    int _front, _back, _count;
+    TP *_data;
+    int _maxitems;
+  public:
+    TPQ(int maxitems = 256) { 
+      _front = 0;
+      _back = 0;
+      _count = 0;
+      _maxitems = maxitems;
+      _data = new TP[maxitems + 1];   
+    }
+    ~TPQ() {
+      delete[] _data;  
+    }
+    void push(const TP &item);
+    TP peek_item(const TP &item);
+};
+
+
+
+template<class TP>
+void TPQ<TP>::push(const TP &item)
+{
+  if(_count < _maxitems) { // Drops out when full
+    _data[_back++]=item;
+    ++_count;
+    // Check wrap around
+    if (_back > _maxitems)
+      _back -= (_maxitems + 1);
+  }
+}
+
+
+
+
+template<class TP>
+TP TPQ<TP>::peek_item(const TP &item) {
+  if(_count <= 0) return TP(); // Returns empty
+  else { 
+    TP result = item;// T result = _data[_front];
+    //_front++;
+    //--_count;
+     if (_front > _maxitems) 
+      _front -= (_maxitems + 1);
+  return result;
+  }
+}
+
+#endif

SE/stuff/P5_Automation_can-dev-res/_bak/_DISPLAY_func.bakh.h

@@ -0,0 +1,181 @@
+//_DISPLAY_func.h
+
+/* #if defined(HAS_TFT_ILI9163C)
+                                    delay(LCDtim);  
+                                    DISPLAY_DEV.setCursor(0,60); 
+                                    DISPLAY_DEV.print(LCDarray1); DISPLAY_DEV.print(" "); DISPLAY_DEV.print(LCDarray2);
+                              #endif
+                              */
+                              
+                              
+//void _DISPLAY_print
+
+
+void DISPLAY__print_ANY(DISPLAY_T_ARDUINO_ATTR_ARRAY_T &DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+                         DISPLAY_PHYSICAL_CHAR_T &DISPLAY_PHYSICAL_CHAR_A,
+                        DISPLAY_pos_seq_T DISPLAY_pos_seq_A,
+                        DISPLAY_array16_T DISPLAY_array16_A){
+              
+                        #if defined(DEBUG)
+                                if(DEBUG > 6) {
+                                    Serial.print("#20 DsplY:[ "); Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                                    Serial.print("] # MaxY:["); Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_Y_CHARS_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                                     Serial.println("] ");
+                                   }
+                                   
+                                     Serial.print("#26 Dspl ATTR CURRENT[ "); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A);
+                                     Serial.print("] LAST["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A); 
+                                     Serial.print("] COUNT["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A); 
+                                     Serial.print("] LIMIT["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A); 
+                                     Serial.print("]  NEXT:["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A); 
+                                     Serial.println("] ");
+                            #endif 
+                
+                 #if defined(HAS_TFT_ILI9163C)
+                       
+                 #endif
+                     #if defined(DEBUG)
+                        if(DEBUG > 6) {
+                             Serial.print(" [HAS_TFT_ILI9163C] ");
+                               Serial.print(" 27[DEBUG] ");
+                           }
+                    #endif 
+                Serial.println("] "); 
+              
+                //todo position current   
+                //todo positions max
+                    #if defined(HAS_TFT_ILI9163C)
+                            DISPLAY_DEV_CTRL__println(DISPLAY_PHYSICAL_CHAR_A, DISPLAY_array16_A) ;
+                    #else 
+                
+                        Serial.println(DISPLAY_array16_A);
+                  
+                    #endif
+                  
+                    #if defined(DEBUG)
+                            //Serial.end(); 
+                            //delay(100);
+                            //Serial.write(" 72[DEBUG] ");
+                    #endif    
+                
+        }
+
+
+
+void DISPLAY__print_IMMEDIATE(
+    DISPLAY_T_ARDUINO_ATTR_ARRAY_T &DISPLAY_T_ARDUINO_ATTR_ARRAY_A, 
+    DISPLAY_PHYSICAL_CHAR_T &DISPLAY_PHYSICAL_CHAR_A, 
+     DISPLAY_pos_seq_T DISPLAY_pos_seq_A,
+     DISPLAY_array16_T DISPLAY_array16_A,
+      DISPLAY_TARGET_T DISPLAY_TARGET_A) {
+        
+        if(DISPLAY_TARGET_A | DISPLAY_TARGET_DISPLAY128){
+        
+                    #if defined(HAS_TFT_ILI9163C)
+                                #if defined(DEBUG)
+                                            if(DEBUG > 6) {
+                                                    String message(DISPLAY_array16_A);
+                                                   Serial.print("#69A DISPLAY__print_IMMEDIATE [DEBUG] to HAS_TFT_ILI9163C  Len["); Serial.print( message.length());
+                                                     Serial.print("] XM["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A);
+                                                     Serial.print("] YM["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_Y_CHARS_A);
+                                                     Serial.print("] YC["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A);
+                                                    Serial.print("] YF["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A);
+                                                   Serial.println("]  ");
+                                                }
+                                           #endif
+                            DISPLAY_DEV_CTRL__println(DISPLAY_PHYSICAL_CHAR_A, DISPLAY_array16_A) ;
+                    #else 
+                
+                        Serial.println(DISPLAY_array16_A);
+                  
+                    #endif
+                             //   DISPLAY__print_ANY(DISPLAY_T_ARDUINO_ATTR_ARRAY_A, DISPLAY_PHYSICAL_CHAR_A, DISPLAY_pos_seq_A, DISPLAY_array16_A);     
+          } else if(DISPLAY_TARGET_A | DISPLAY_TARGET_ANY){
+                                        #if defined(DEBUG)
+                                                if(DEBUG > 6) {
+                                                   Serial.print("#69B DISPLAY__print_IMMEDIATE [DEBUG] to DISPLAY__print_ANY  Seq["); Serial.print(DISPLAY_pos_seq_A , BIN);
+                                                    Serial.print("] Target["); Serial.print(DISPLAY_TARGET_A , BIN);
+                                                   Serial.println("]  ");
+                                                  }
+                                           #endif
+                                DISPLAY__print_ANY(DISPLAY_T_ARDUINO_ATTR_ARRAY_A, DISPLAY_PHYSICAL_CHAR_A, DISPLAY_pos_seq_A, DISPLAY_array16_A);     
+          } else {
+                              #if defined(DEBUG)
+                                    if(DEBUG > 6) {
+                                        Serial.print("#68 DISPLAY__print_IMMEDIATE [DEBUG]  else  Seq["); Serial.print(DISPLAY_pos_seq_A , BIN);
+                                         Serial.print("] Target["); Serial.print(DISPLAY_TARGET_A , BIN);
+                                        Serial.println("]  ");
+                                    }
+                                #endif  
+          }
+
+}
+
+        
+        
+        
+
+
+
+ void DISPLAY__print(
+        DISPLAY_T* DISPLAY_A ,
+        DISPLAY_T_ARDUINO_ATTR_ARRAY_T &DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+        DISPLAY_PHYSICAL_CHAR_T &DISPLAY_PHYSICAL_CHAR_A, 
+        DISPLAY_pos_seq_T DISPLAY_pos_seq_A,
+        DISPLAY_array16_T DISPLAY_array16_A,
+        DISPLAY_TARGET_T DISPLAY_TARGET_A,
+        time_seq_id_T time_seq_id_A,
+        time_min_run_T time_min_run_A
+        //queue
+        ,Slave_Ports_Status_QUEUE_T* Slave_Ports_Status_QUEUE_A,
+        TASK_TYPE_T TASK_TYPE_A,
+        TASK_PORT_ASSOC_T TASK_PORT_ASSOC_A
+                )
+                {
+                
+                    #if defined(DEBUG)
+                            Serial.print("#26 Dspl ATTR CURRENT[ "); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_CURRENT_A);
+                                     Serial.print("] LAST["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LAST_A); 
+                                     Serial.print("] COUNT["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_COUNT_A); 
+                                     Serial.print("] LIMIT["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_LIMIT_A); 
+                                     Serial.print("]  NEXT:["); Serial.print(DISPLAY_T_ARDUINO_ATTR_ARRAY_A.ARDUINO_ARRAY_INDEX_NEXT_A); 
+                                     Serial.println("] ");
+                    #endif
+                    
+                    if(DISPLAY_pos_seq_A | DISPLAY_pos_seq_A_IMMEDIATE){
+                            #if defined(DEBUG)
+                                    if(DEBUG > 6) {
+                                        Serial.print("#84 DISPLAY__print to DISPLAY__print_IMMEDIATE [DEBUG]  else  Seq["); Serial.print(DISPLAY_pos_seq_A , BIN);
+                                        Serial.print("] Target["); Serial.print(DISPLAY_TARGET_A , BIN); 
+                                        
+                                        Serial.println("]  ");
+                                     }
+                                #endif  
+                           DISPLAY__print_IMMEDIATE(DISPLAY_T_ARDUINO_ATTR_ARRAY_A, DISPLAY_PHYSICAL_CHAR_A, DISPLAY_pos_seq_A,  DISPLAY_array16_A,  DISPLAY_TARGET_A);
+                                     // Serial.print("#28 running _Slave_Ports_ttl_decrement = ");
+                
+                    } else {
+                          #if defined(DEBUG)
+                                 Serial.print("#88 DISPLAY__print [DEBUG]  else  "); Serial.print(DISPLAY_pos_seq_A , BIN);
+                                 Serial.println("]  ");
+                         #endif    
+                         
+                         
+                      DISPLAY__add_record(  DISPLAY_A ,
+                             DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
+                             DISPLAY_PHYSICAL_CHAR_A, 
+                             DISPLAY_pos_seq_A,
+                             DISPLAY_array16_A,
+                             DISPLAY_TARGET_A,
+                             time_seq_id_A,
+                             time_min_run_A
+                             //queue
+                             , Slave_Ports_Status_QUEUE_A,
+                             TASK_TYPE_A,
+                             TASK_PORT_ASSOC_A
+                         ) ;
+                         
+                    }
+}
+
+

SE/stuff/P5_Automation_can-dev-res/_bak/_DISPLAY_struct.bakh.h

@@ -0,0 +1,78 @@
+
+
+typedef  char DISPLAY_array16_T[16] ;
+
+
+ typedef int DISPLAY_PHYSICAL_X_PX_T ;
+ typedef int DISPLAY_PHYSICAL_Y_PX_T ;
+
+
+ typedef int DISPLAY_PHYSICAL_X_CHARS_T ;
+ typedef int DISPLAY_PHYSICAL_Y_CHARS_T ;
+
+ typedef int DISPLAY_CURSOR_X_CHARS_T ;
+ typedef int DISPLAY_CURSOR_Y_CHARS_T ;
+ 
+ 
+  typedef int DISPLAY_textsize_T ;
+  typedef DISPLAY_textsize_T DISPLAY_textsize_x_T ;
+  typedef DISPLAY_textsize_T DISPLAY_textsize_y_T ;
+
+
+
+
+
+typedef  int DISPLAY_pos_seq_T ; //reqiested position in LCD
+    const DISPLAY_pos_seq_T DISPLAY_pos_seq_A_EXACT            = B00000001;
+    const DISPLAY_pos_seq_T DISPLAY_pos_seq_A_NEXT             = B00000010;
+    const DISPLAY_pos_seq_T DISPLAY_pos_seq_A_IMMEDIATE        = B00000100;
+    const DISPLAY_pos_seq_T DISPLAY_pos_seq_A_QUEUE            = B00001000;
+    const DISPLAY_pos_seq_T DISPLAY_pos_seq_A_ATTIME           = B00010000;
+    const DISPLAY_pos_seq_T DISPLAY_pos_seq_A_INVALIDAFTER     = B00100000;
+typedef  int DISPLAY_pos_id_T ; //reqiested position id in LCD
+
+ 
+typedef int DISPLAY_TARGET_T ;
+
+ struct DISPLAY_S {
+      int _queue_id ; //current queue task
+       DISPLAY_pos_seq_T DISPLAY_pos_seq_A = DISPLAY_pos_seq_A_NEXT;
+       DISPLAY_pos_id_T DISPLAY_pos_id_A; //somehow like position id for menus...
+       DISPLAY_array16_T DISPLAY_array16_A ;
+       DISPLAY_TARGET_T DISPLAY_TARGET_A ; 
+       time_seq_id_T time_seq_id_A;
+       time_min_run_T time_min_run_A;
+    } ;
+    
+typedef struct DISPLAY_S DISPLAY_T ;
+    
+ 
+ struct DISPLAY_PHYSICAL_CHAR_S {
+ 
+           DISPLAY_PHYSICAL_X_PX_T DISPLAY_PHYSICAL_X_PX_A ;
+           DISPLAY_PHYSICAL_Y_PX_T DISPLAY_PHYSICAL_Y_PX_A ;
+           DISPLAY_PHYSICAL_X_CHARS_T DISPLAY_PHYSICAL_X_CHARS_A;
+           DISPLAY_PHYSICAL_Y_CHARS_T DISPLAY_PHYSICAL_Y_CHARS_A;
+           DISPLAY_CURSOR_X_CHARS_T DISPLAY_CURSOR_X_CHARS_A;
+           DISPLAY_CURSOR_Y_CHARS_T DISPLAY_CURSOR_Y_CHARS_A ;
+           DISPLAY_textsize_x_T DISPLAY_textsize_x_A;
+           DISPLAY_textsize_y_T DISPLAY_textsize_y_A;
+ } ;
+ 
+ 
+ const DISPLAY_TARGET_T  DISPLAY_TARGET_CONSOLE      = B00000001 ;
+ const DISPLAY_TARGET_T  DISPLAY_TARGET_LCD16        = B00000010 ;
+ const DISPLAY_TARGET_T  DISPLAY_TARGET_DISPLAY128   = B00000100 ;
+ const DISPLAY_TARGET_T  DISPLAY_TARGET_ALL          =            DISPLAY_TARGET_CONSOLE + DISPLAY_TARGET_LCD16 + DISPLAY_TARGET_DISPLAY128 ;
+ const DISPLAY_TARGET_T  DISPLAY_TARGET_ANY          = B00001000 + DISPLAY_TARGET_CONSOLE + DISPLAY_TARGET_LCD16 + DISPLAY_TARGET_DISPLAY128 ;
+ 
+ 
+ 
+ typedef struct ARDUINO_ATTR_ARRAY_S DISPLAY_T_ARDUINO_ATTR_ARRAY_T ;
+ 
+ 
+
+ 
+typedef struct ARDUINO_ARRAY_INDEX_TABLE_S         DISPLAY_ARDUINO_ARRAY_INDEX_TABLE_T ; //DEFAULT INDEX TABLE
+typedef struct ARDUINO_ARRAY_INDEX_T_TO_DELETE_S   DISPLAY_ARDUINO_ARRAY_INDEX_T_TO_DELETE_T;
+ typedef ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_FUNCT_INIT_RESULT_Slave_Ports_queue__add_DISPLAY_T ;

SE/stuff/P5_Automation_can-dev-res/_bak/_TFT_ILI9163C_func.bakh.h

@@ -0,0 +1,171 @@
+//   DISPLAY_DEV.setCursor(0,60); 
+//   DISPLAY_DEV.print(LCDarray1); DISPLAY_DEV.print(" "); DISPLAY_DEV.print(LCDarray2);
+
+
+ TFT_ILI9163C DISPLAY_DEV = TFT_ILI9163C(TFT_ILI9163C_CSpin, TFT_ILI9163C_DCpin, TFT_ILI9163C__RSTpin);
+
+//defineScrollArea
+//scroll
+//startPushData(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
+//	void 		pushData(uint16_t color);
+//	void 		endPushData();
+//fillRect(int16_t x, int16_t y, int16_t w, int16_t h,uint16_t color),
+//				setRotation(uint8_t r),
+//drawPixel(int16_t x, int16_t y, uint16_t color),
+//				drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
+//				drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
+
+/*
+ 
+void TFT_ILI9163C_BASE::defineScrollArea(uint16_t tfa, uint16_t bfa){
+    tfa += __OFFSET ;
+    int16_t vsa = _GRAMHEIGH - tfa - bfa;
+    if (vsa >= 0) {
+        writecommand(CMD_VSCLLDEF);
+        writedata16(tfa);
+        writedata16(vsa);
+        writedata16(bfa);
+    }
+}
+ 
+void TFT_ILI9163C_BASE::scroll(uint16_t ssa) {
+    if (ssa <= _TFTHEIGHT) {
+        writecommand(CMD_VSSTADRS);
+        writedata16(ssa + __OFFSET);
+    }
+}
+ 
+  
+  int16_t getCursorX(void) const { return cursor_x; }
+
+    @brief      Get text cursor Y location
+    @returns    Y coordinate in pixels
+  int16_t getCursorY(void) const { return cursor_y; };
+  
+  
+  write - 
+
+
+  tft.fillScreen();
+  unsigned long start = micros();
+  tft.setCursor(0, 0);
+  tft.setTextColor(WHITE);  
+  tft.setTextSize(1);
+  tft.println("Hello World!");
+  tft.setTextColor(YELLOW); 
+  tft.setTextSize(2);
+  tft.println(1234.56);
+  tft.setTextColor(RED);    
+  tft.setTextSize(3);
+  tft.println(0xDEAD, HEX);
+  tft.println();
+  tft.setTextColor(GREEN);
+  tft.setTextSize(4);
+  tft.println("Hello");
+  return micros() - start;
+
+*/
+
+void DISPLAY_DEV__CURSOR__NEWLINE(DISPLAY_PHYSICAL_CHAR_T &DISPLAY_PHYSICAL_CHAR_A) { 
+    if(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A + 1 >= DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_Y_CHARS_A) {//[ARDUINO_ATTR_ARRAY_S_INDEX]
+        DISPLAY_DEV.setCursor(0,0);
+         //DISPLAY_DEV.clearScreen();
+       DISPLAY_DEV.fillRect(0, 0, DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_PX_A , DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A  ,BLUE),    
+         DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A = 0 ; //[ARDUINO_ATTR_ARRAY_S_INDEX]
+         DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_X_CHARS_A = 0 ; //[ARDUINO_ATTR_ARRAY_S_INDEX]
+    } else {
+    
+         DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A ++ ; //[ARDUINO_ATTR_ARRAY_S_INDEX]
+         DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_X_CHARS_A = 0 ; //[ARDUINO_ATTR_ARRAY_S_INDEX]
+         
+         DISPLAY_DEV.setCursor(0,DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A * DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+         DISPLAY_DEV.fillRect(0, DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A * DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A, DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_PX_A , DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A  ,BLUE);
+    }
+    
+           #if defined(DEBUG)
+                if(DEBUG > 6) {     
+                     Serial.print("#83 Dspl Y:["); Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                     Serial.print("] #MaxY:["); Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_Y_CHARS_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                     Serial.print("]  maxX:["); Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                     Serial.print("]  x_A:["); Serial.print(DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_x_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                     
+                     //Serial.print("] #YxF:["); Serial.print(&DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A *  DISPLAY_PHYSICAL_CHAR_A.DISPLAY_textsize_y_A); //[ARDUINO_ATTR_ARRAY_S_INDEX]
+                     Serial.println("] "); 
+                }
+            #endif
+}
+
+
+
+
+
+
+void  DISPLAY_DEV_CTRL__println(DISPLAY_PHYSICAL_CHAR_T &DISPLAY_PHYSICAL_CHAR_A, 
+                                DISPLAY_array16_T DISPLAY_array16_A) {
+                                DISPLAY_DEV__CURSOR__NEWLINE(DISPLAY_PHYSICAL_CHAR_A) ; 
+                               // DISPLAY_DEV.print(DISPLAY_array16_A);
+                               //  unsigned char LCDarray1buf[16];
+                                 //              DISPLAY_array16_A.toCharArray(LCDarray1buf, 16);
+                                 
+                                  String message(DISPLAY_array16_A);
+                                
+                                 
+                               
+                                int parts =  floor(message.length()/ DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A ) ; //( message.length() + 100)
+                                if(message.length() >= DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A and parts == 1) parts ++; 
+                                else if(parts == 0) parts = 1;
+                                int substr_begin = 0 ;
+                                int substr_end = 0 ;
+                                int i;
+                                
+                                 #if defined(DEBUG) 
+                                  if(DEBUG > 6) {  
+                                     Serial.print("#34 arr16"); Serial.print(DISPLAY_array16_A);
+                                     Serial.print("] #34 sizeof["); Serial.print(message.length());
+                                     Serial.print("] #34 String["); Serial.print(message);
+                                     Serial.print("] #34 frag"); Serial.print( message.substring(2, 5));
+                                     Serial.print("] parts["); Serial.print( parts);
+                                     Serial.print("] yC["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_CURSOR_Y_CHARS_A);
+                                     Serial.println("] "); 
+                                     }
+                                 #endif
+                                
+                                
+                                
+                                for(i = 1 ; i<= parts; i++) {
+                                    //myString.substring(from, to)
+                                    substr_end = substr_begin + DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A ;
+                                    DISPLAY_DEV.print(message.substring(substr_begin, substr_end));
+                                       /*BUG TODO ERROR IF UNCOMMENTED*/
+                                       #if defined(DEBUG)
+                                       if(DEBUG > 6) {  
+                                              Serial.print("#112 msg part["); Serial.print(i);
+                                             Serial.print("]  beg["); Serial.print(substr_begin);
+                                             Serial.print("]  end["); Serial.print(substr_end);
+                                             Serial.print("]  frag["); Serial.print(message.substring(substr_begin, substr_end));
+                                             Serial.print("] yC["); Serial.print( DISPLAY_PHYSICAL_CHAR_A.DISPLAY_PHYSICAL_X_CHARS_A);
+                                             Serial.println("] ");
+                                            } 
+                                         #endif
+                                         
+                                        substr_begin = substr_end + 1;
+                                        if( parts >= 1 and not(parts == i)) {
+                                            
+                                             DISPLAY_DEV__CURSOR__NEWLINE(DISPLAY_PHYSICAL_CHAR_A) ;
+                                        } //else if(i == parts) {
+                                          //  DISPLAY_DEV__CURSOR__NEWLINE(DISPLAY_PHYSICAL_CHAR_A) ;
+                                       // }
+                                } 
+                                /*BUG TODO ERROR IF UNCOMMENTED
+                                // Serial.end();    // Ends the serial communication once all data is received
+                                //Serial.begin(115200);  
+                               // delay(400);
+                               // if (Serial.available()) Serial.write("aaaa49 ");
+                                //delay(100);
+                               // if (Serial.available()) Serial.println("bbbb49 ");
+                              //  else  Serial.println("cccc49 ");
+                              */
+            }
+            
+            
+