a

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

@@ -98,7 +98,10 @@
 #include "_time_struct.h"
 
 #include "__main_I2C_struc.h"
-
+#include "__main_static.h"
+#include "__main_auto.h"
+#include "__main_register.h"
+#include "__main_extern.h"
 
 #define  _ControllerID   0x101 
 #define  _Slave1_ID   0x103 

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

@@ -1,11 +1,20 @@
  if(oldEncPos != encoderPos) {
+ 
+    
+    static I2C_INDEX_DRIVER_T I2C_INDEX_DRIVER_A ;
+ 
     Serial.print(" ROT_SW[");  Serial.print(encoderPos);  Serial.print("] ");  
     oldEncPos = encoderPos;
     
-     Serial.print("#550 CLK_AAdafruit_PWMServoDriver: #[");  Serial.print(encoderPos);  Serial.println(" ] ");   
+    if(not(I2C_INDEX_DRIVER_A > 0)) {
+    I2C_INDEX_DRIVER_A = Adafruit_PWMServoDriver__get_PRIMARY_KET_T(Adafruit_PWMServoDriver_A,  I2C_ADDRESS_0x40) ;
+    }
+     Serial.print("#550 CLK_AAdafruit_PWMServoDriver: #[");  Serial.print(encoderPos);
+     Serial.print("] I2C_INDEX_DRIVER_A [");  Serial.print(I2C_INDEX_DRIVER_A); 
+      Serial.println(" ] ");   
      //Adafruit_PWMServoDriver_0X40.setPWM(1, 0, map(encoderPos, 0, 180, SERVOMIN, SERVOMAX));
     // Adafruit_PWMServoDriver_0X40.setPWM(2, encoderPos * 5, encoderPos * 50);
-        Adafruit_PWMServoDriver_A[1].Adafruit_PWMServoDriver_V.setPWM(2, encoderPos * 5, encoderPos * 50);
+        Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(2, encoderPos * 5, encoderPos * 50);
 
 DISPLAY__CURSOR_Y_CHARS__SET(DISPLAY_PHYSICAL_CHAR_A, 
                                 DISPLAY_CURSOR_Y_CHARS_DEBUG);

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

@@ -17,9 +17,16 @@
         ,TASK_TYPE_T TASK_TYPE_A,
         TASK_PORT_ASSOC_T TASK_PORT_ASSOC_A   , 
         Adafruit_PWMServoDriver_T* Adafruit_PWMServoDriver_A
-    ) {
-         
-         
+    ) {     
+    
+    
+    
+    I2C_INDEX_DRIVER_T I2C_INDEX_DRIVER_A ;
+    //auto I2C_INDEX_DRIVER_T I2C_INDEX_DRIVER_A  ;
+    
+    
+    
+    
            DISPLAY__print(
                           DISPLAY_A ,
                           DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
@@ -61,10 +68,11 @@
              #endif
                
                     if(Slave_Ports_Status_A[i].I2C_driver == I2C_driver_Adafruit_PWMServoDriver) {
-                          ARDUINO_ARRAY_PRIMARY_KET_T  Adafruit_PWMServoDriver__get_PRIMARY_KET_A = Adafruit_PWMServoDriver__get_PRIMARY_KET_T(
+                          //ARDUINO_ARRAY_PRIMARY_KET_T  Adafruit_PWMServoDriver__get_PRIMARY_KET_A = Adafruit_PWMServoDriver__get_PRIMARY_KET_T(
+                          I2C_INDEX_DRIVER_A = Adafruit_PWMServoDriver__get_PRIMARY_KET_T(
                                 Adafruit_PWMServoDriver_A, Slave_Ports_Status_A[i].Address);
                                 
-                            if(Adafruit_PWMServoDriver__get_PRIMARY_KET_A > 0 ) {//Slave_Ports_Status_A[i].Address == I2C_ADDRESS_0x40 ) {
+                            if(I2C_INDEX_DRIVER_A > 0 ) {//Slave_Ports_Status_A[i].Address == I2C_ADDRESS_0x40 ) {
                                   /*  if(I2C_ADDRESS_0x40_A == ARDUINO_DRIVER_UNDEFINED) {
                                        // Adafruit_PWMServoDriver  Adafruit_PWMServoDriver_0X40 = Adafruit_PWMServoDriver(0x40);
                                         I2C_ADDRESS_0x40_A = ARDUINO_DRIVER_INITIALIZED ;
@@ -78,29 +86,29 @@
                                     if(Slave_Ports_Status_A[i].PortTypes | PortTypes_SERVO) {
                                                 if(Slave_Ports_Status_A[i].Exp_state | Exp_state_ON) {
                                     
-                                                         Adafruit_PWMServoDriver_A[Adafruit_PWMServoDriver__get_PRIMARY_KET_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0, map(90, 0, 180, SERVOMIN, SERVOMAX));
+                                                         Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0, map(90, 0, 180, SERVOMIN, SERVOMAX));
                                                          Slave_Ports_Status_A[i].Exp_state = Slave_Ports_Status_A[i].Exp_state + Exp_state_SET;
                                                          Slave_Ports_Status_A[i].Exp_state_ttl = Exp_state_ttl_IS_ACTIVE ;
                                                 } else if(Slave_Ports_Status_A[i].Exp_state | Exp_state_OFF)  {
-                                                         Adafruit_PWMServoDriver_A[Adafruit_PWMServoDriver__get_PRIMARY_KET_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0, map(0, 0, 180, SERVOMIN, SERVOMAX));
+                                                         Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0, map(0, 0, 180, SERVOMIN, SERVOMAX));
                                                          Slave_Ports_Status_A[i].Exp_state = Slave_Ports_Status_A[i].Exp_state + Exp_state_SET;
                                                          Slave_Ports_Status_A[i].Exp_state_ttl = Exp_state_ttl_IS_ACTIVE ;
                                                 }
                                     } else {
                                     
                                                     if(Slave_Ports_Status_A[i].Exp_state == Exp_state_ON ) {
-                                                        Adafruit_PWMServoDriver_A[Adafruit_PWMServoDriver__get_PRIMARY_KET_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 3000, 3000);
+                                                        Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 3000, 3000);
                                                         Serial.print("#77 I2C_driver Exp_state [ON]"); Serial.print(Slave_Ports_Status_A[i].Exp_state); Serial.println("] ");
                                                         Slave_Ports_Status_A[i].Exp_state = Slave_Ports_Status_A[i].Exp_state + Exp_state_SET;
                                                         Slave_Ports_Status_A[i].Exp_state_ttl = Exp_state_ttl_IS_ACTIVE ;
                                                     } else if(Slave_Ports_Status_A[i].Exp_state == Exp_state_OFF ){
-                                                        Adafruit_PWMServoDriver_A[Adafruit_PWMServoDriver__get_PRIMARY_KET_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0, 0);
+                                                        Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0, 0);
                                                         Serial.print("#77 I2C_driver Exp_state [OFF]"); Serial.print(Slave_Ports_Status_A[i].Exp_state); Serial.println("] ");
                                                         Slave_Ports_Status_A[i].Exp_state = Slave_Ports_Status_A[i].Exp_state + Exp_state_SET;
                                                     } else if(Slave_Ports_Status_A[i].Exp_state == Exp_state_BLINK ){
-                                                         Adafruit_PWMServoDriver_A[Adafruit_PWMServoDriver__get_PRIMARY_KET_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0,2000);
+                                                         Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0,2000);
                                                       //   delay(1000);
-                                                         Adafruit_PWMServoDriver_A[Adafruit_PWMServoDriver__get_PRIMARY_KET_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0,1000);
+                                                         Adafruit_PWMServoDriver_A[I2C_INDEX_DRIVER_A].Adafruit_PWMServoDriver_V.setPWM(Slave_Ports_Status_A[i].LocalPort, 0,1000);
                                                          Slave_Ports_Status_A[i].Exp_state = Slave_Ports_Status_A[i].Exp_state + Exp_state_ERROR;
                                                          Slave_Ports_Status_A[i].Exp_state_ttl = Exp_state_ttl_IS_ACTIVE ;
                                                     } else {

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

@@ -21,13 +21,24 @@ typedef ARDUINO_DRIVER_STATUS_T   I2C_ADDRESS_0x42_T;
 typedef ARDUINO_DRIVER_STATUS_T   I2C_ADDRESS_0x43_T;
 typedef ARDUINO_DRIVER_STATUS_T   I2C_ADDRESS_0x44_T; 
 
+//static ARDUINO_ARRAY_INDEX_T ARDUINO_ARRAY_INDEX_T;
 
 
-I2C_ADDRESS_0x40_T I2C_ADDRESS_0x40_A = ARDUINO_DRIVER_UNDEFINED ;
-I2C_ADDRESS_0x41_T I2C_ADDRESS_0x41_A = ARDUINO_DRIVER_UNDEFINED ;
+
+ //test global
+static I2C_ADDRESS_0x40_T I2C_ADDRESS_0x40_A = ARDUINO_DRIVER_UNDEFINED ;
+static I2C_ADDRESS_0x41_T I2C_ADDRESS_0x41_A = ARDUINO_DRIVER_UNDEFINED ;
 I2C_ADDRESS_0x42_T I2C_ADDRESS_0x42_A = ARDUINO_DRIVER_UNDEFINED ;
 I2C_ADDRESS_0x43_T I2C_ADDRESS_0x43_A = ARDUINO_DRIVER_UNDEFINED ;
 I2C_ADDRESS_0x44_T I2C_ADDRESS_0x44_A = ARDUINO_DRIVER_UNDEFINED ;
 
 
 
+
+
+
+typedef ARDUINO_ARRAY_INDEX_T I2C_INDEX_DRIVER_T ; //DO NP INDEX GDIZE JEST ZAINCJALIZOWANY JAKIS HANDLER  Adafruit_PWMServoDriver_A[i].I2C_ADDRESS_A ...
+ 
+
+
+

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

@@ -0,0 +1,15 @@
+
+
+
+
+//auto int degrees;
+
+
+
+
+
+// ARDUINO_ARRAY_INDEX_DRIVER_T ARDUINO_ARRAY_INDEX_DRIVER_A = NULL ; //global 
+
+// ARDUINO_ARRAY_INDEX_T I2C_INDEX_DRIVER_A ;
+
+

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

@@ -0,0 +1,41 @@
+/*
+The extern Storage Class
+The extern storage class is used to give a reference of a global variable that is visible to ALL 
+the program files. When you use 'extern', the variable cannot be initialized however, 
+it points the variable name at a storage location that has been previously defined.
+
+When you have multiple files and you define a global variable or function, which will also be used in
+ other files, then extern will be used in another file to provide the reference of defined variable or function. 
+ Just for understanding, extern is used to declare a global variable or function in another file.
+
+The extern modifier is most commonly used when there are two or more files sharing the same global 
+variables or functions as explained below.
+
+First File: main.c
+
+#include <stdio.h>
+ 
+int count ;
+extern void write_extern();
+ 
+main() {
+   count = 5;
+   write_extern();
+}
+Second File: support.c
+
+#include <stdio.h>
+ 
+extern int count;
+ 
+void write_extern(void) {
+   printf("count is %d\n", count);
+}
+Here, extern is being used to declare count in the second file, where as it has its definition in the first 
+file, main.c. Now, compile these two files as follows −
+
+$gcc main.c support.c
+It will produce the executable program a.out. When this program is executed, it produces the following result −
+
+count is 5
+*/

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

@@ -0,0 +1,13 @@
+ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_FUNCT_INIT_RESULT_Slave_Ports_queue__add ;
+ARDUINO_FUNCT_INIT_RESULT_T ARDUINO_FUNCT_INIT_RESULT__Slave_Ports_LOCAL_init ;
+
+
+
+ARDUINO_LOOP_LATENCY_T                  ARDUINO_LOOP_LATENCY__MAIN_A = 10 ; //EVERY 10 LOOPS INIT THIS LATENCY
+ARDUINO_LOOP_LATENCY_COUNTER_T  ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A = ARDUINO_LOOP_LATENCY_COUNTER_INIT ; //WILL decrement
+
+
+
+
+ARDUINO_LOOP_LATENCY_T                  ARDUINO_LOOP_LATENCY__MAIN_END_A = 100 ; //EVERY 10 LOOPS INIT THIS LATENCY
+ARDUINO_LOOP_LATENCY_COUNTER_T  ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A = ARDUINO_LOOP_LATENCY_COUNTER_INIT ; //WILL DECREMENT

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

@@ -0,0 +1,19 @@
+/*
+
+The register Storage Class
+The register storage class is used to define local variables that should be stored 
+in a register instead of RAM.
+ This means that the variable has a maximum size equal to the register 
+ size (usually one word) and can't have the unary '&' operator applied to it 
+ (as it does not have a memory location).
+
+{
+   register int  miles;
+}
+The register should only be used for variables that require quick access 
+such as counters. It should also be noted that defining 'register' 
+does not mean that the variable will be stored in a register. 
+It means that it MIGHT be stored in a register depending on hardware and 
+implementation restrictions.
+
+*/

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

@@ -0,0 +1,21 @@
+/*
+
+
+The static Storage Class
+The static storage class instructs the compiler to keep a local variable
+ in existence during the life-time of the program instead of creating and 
+ destroying it each time it comes into and goes out of scope. Therefore, 
+ making local variables static allows them to maintain their values between 
+ function calls.
+
+The static modifier may also be applied to global variables. When this is done, 
+it causes that variable's scope to be restricted to the file in which it is declared.
+
+In C programming, when static is used on a global variable, it causes only one 
+copy of that member to be shared by all the objects of its class.
+
+*/
+
+
+
+static ARDUINO_ARRAY_time_min_run_MIN_T  ARDUINO_ARRAY_time_min_run_MIN_A; 

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

@@ -1,9 +1,34 @@
+/*
 
+https://www.tutorialspoint.com/cprogramming/c_storage_classes.htm
+
+A storage class defines the scope (visibility) and life-time of variables and/or functions within a C Program. They precede the type that they modify. We have four different storage classes in a C program −
+
+auto
+register
+static
+extern
+
+
+
+The auto Storage Class
+The auto storage class is the default storage class for all local variables.
+
+{
+   int mount;
+   auto int month;
+}
+The example above defines two variables with in the same storage class.
+ 'auto' can only be used within functions, i.e., local variables.
+
+*/
 
 typedef int  ARDUINO_SIZE_T ; //for display etc
 typedef ARDUINO_SIZE_T  ARDUINO_SIZE_MIN_T ; //for display etc
 typedef ARDUINO_SIZE_T  ARDUINO_SIZE_MAX_T ; //for display etc
 
+typedef byte ARDUINO_ARRAY_INDEX_DRIVER_STATUS_T ; //status inicjalizacji drivera
+
 typedef int ARDUINO_LOOP_LATENCY_T;
 typedef int ARDUINO_LOOP_LATENCY_COUNTER_T; //WILL increment
 const ARDUINO_LOOP_LATENCY_COUNTER_T ARDUINO_LOOP_LATENCY_COUNTER_INIT = 1 ; //
@@ -56,6 +81,17 @@ struct ARDUINO_ARRAY_ASSOC_TABLE_S {  //to associate and cache
 
 
 
+//typedef ARDUINO_ARRAY_ATTR_T ARDUINO_ARRAY_DRIVER
+typedef ARDUINO_ARRAY_INDEX_T ARDUINO_ARRAY_INDEX_DRIVER_T ; //DO NP INDEX GDIZE JEST ZAINCJALIZOWANY JAKIS HANDLER  Adafruit_PWMServoDriver_A[i].I2C_ADDRESS_A ...
+
+
+
+
+const ARDUINO_ARRAY_INDEX_DRIVER_STATUS_T  ARDUINO_ARRAY_INDEX_DRIVER_STATUS_TO_INIT_A   = B00000001 ; // to init - e.g. Adafruit_PWMServoDriver_A[i].Adafruit_PWMServoDriver_V = Adafruit_PWMServoDriver(Adafruit_PWMServoDriver_A[i].I2C_ADDRESS_A);  status inicjalizacji drivera
+const ARDUINO_ARRAY_INDEX_DRIVER_STATUS_T  ARDUINO_ARRAY_INDEX_DRIVER_STATUS_TO_SETUP_A  = B00000010 ; //like in setup loop Adafruit_PWMServoDriver_A[i].Adafruit_PWMServoDriver_V.begin(); status inicjalizacji drivera
+const ARDUINO_ARRAY_INDEX_DRIVER_STATUS_T  ARDUINO_ARRAY_INDEX_DRIVER_STATUS_TO_SETVAL_A = B00000100 ; //like Adafruit_PWMServoDriver_A[i].Adafruit_PWMServoDriver_V.setPWM(LocalPort, PWM_MIN, PWM_MAX); status inicjalizacji drivera
+
+
 const ARDUINO_ARRAY_INDEX_T  ARDUINO_ARRAY_INDEX_NOT_SET = 0  ; //for controll arrays behaviour
 const ARDUINO_ARRAY_INDEX_T  ARDUINO_ARRAY_INDEX_CORRUPT = 0  ; //for controll arrays behaviour
 const ARDUINO_ARRAY_INDEX_T  ARDUINO_ARRAY_INDEX_FIRST = 1  ; //for controll arrays behaviour
@@ -100,10 +136,8 @@ const ARDUINO_ARRAY_INDEX_T ARDUINO_ATTR_ARRAY_S_INDEX = ARDUINO_ARRAY_INDEX_FIR
 
 #define SERVOMIN  150 // this is the 'minimum' pulse length count (out of 4096)
 #define SERVOMAX  600 // this is the 'maximum' pulse length count (out of 4096)
-int degrees;
 
 
-ARDUINO_ARRAY_time_min_run_MIN_T  ARDUINO_ARRAY_time_min_run_MIN_A; 
 
 
 #define ArrayElementSize(x) (sizeof()/sizeof(x[0]))
@@ -128,4 +162,16 @@ typedef ARDUINO_ROTTARY_ENC_DIR_S
   val = encoder_direction();
   
   
+  */
+  
+  
+  /*
+  
+class MyObject{
+    uint8_t aByte;  //one byte of memory
+    uint16_t aInt;  //two bytes of memory
+};
+
+MyObject anObject;  //create an instance of MyObject 
+  
   */