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

/* P5_Automation_can-dev
 * 2020-06 testing communications CAN for integrate further with Procesy5
 * A.Binder
 * Uses: 
 * LCD1602 - big 2x16 character display
 * TFT_ILI9163C 128x128 lcd display
 * MCP_2515 - can port controller
 * //#define HAS_I2C_driver_Adafruit_PWMServoDriver
 * controls
 * Slave ports via:     
 * I2C      
 * PCA9685 - 16port 12bit PWM driver - can controll 16 eg. LEDs which can be 0....12V dimmed=]                
 * todo 74HC595 - Serial to Parallel Shifting-Out - from 8 ports to many if connected in paraller
 *       based on https://www.arduino.cc/en/tutorial/ShiftOut 
 * or 16 servos               
 * - can have addressed many of PCA9685 on I2C bus - so can controll over 64 ports      
 * to be added another devices tested
 * todo Rottary Swich { GND, +, SW, DT, CLK } - to provide LCD menu access

 *  TODO structure of port is in _Slave_Ports.h  
 *     _Slave_Port _Slave_Ports[] = {
        {"CAN", 0x102, 0x80, 0x00, 0, 0x00, 0x00 },
        {"CAN",  - Base port origin protocol
          0x102,  - Base port origin protocol address
           0x80, -  int PortTypes;  0xFF  =  1111 1111
                                    0x01  =  0000 0001  = PWM port
                                    {
                                      bit 1 - PWM port
                                      bit 2 - not allocated
                                      bit 3 - not allocated
                                      bit 4 - not allocated
                                      bit 2 - not allocated
                                      bit 5 - not allocated
                                      bit 6 - not allocated
                                      bit 7 - not allocated
                                      bit 8 - not allocated
                                    },
            0x00, int Address -  local address on e.g. I2C bus - 0x40 etc                     
            0x00, - int LocalPort - local port number when used e.g. I2C extension
             0x01 - Exp_state -     0xFF  =  1111 1111
                                    0x00  =  0000 0000  = OFF = 0V
                                    0x01  =  0000 0001  = ON = PWM max
                                              {
                                                bit 1 - OFF = 0V
                                                bit 2 - ON = PWM max
                                                bit 3 - not allocated
                                                bit 4 - not allocated
                                                bit 2 - not allocated
                                                bit 5 - not allocated
                                                bit 6 - not allocated
                                                bit 7 - not allocated
                                                bit 8 - not allocated
                                              }, 
               0x6d - testowy ttl - 10 sekund do przedawnienia stanu portu w tablicy i koniecznosci odswiezenia tablicy
               } 
        };
        - to be optimalized for inegration
        - to allow of subscribe ports
        - to allow of concurent routing
        - to allow new port detectioj
        - to allow creating ports dependencies e.g. IF 
            - port has value
            - port AND port 
            THEN
            - set port
           - probably should be avilable creations of virtual ports which would describe 
            - state of port AND port etc... 
 *  TO BE INTEGRATED WITH p5 
 *    - interface and WFST
 *  TO BE INGEGRATED WITH MARLIN 3D PRINTERS - machine and automation purpose
 *    - controll remote ports via g-code 
 *    - allows interrupts
 *   TO ALLOW OF NEXT PACKETS TYPES WITH DIFFERENT MEANINGS
 *    - dimming
 *    logic
 */

//#define HAS_DEBUG_ACTION_TRIG
//#define DEBUG_I2C //to debug _Slave_Ports_I2C_POP etc
//#define HAS_TFT_ILI9163C 
//#define HAS_LCD1602 
//#define HAS_ROTTARY_SW

//#define DEBUG_I2C_driver_Adafruit_PWMServoDriver
//#define DEBUG_CAN

//#define HAS__PCINT_setup //to allow interrupts

#define HAS__jm_Scheduler //to allow planned actions blink etc

#if defined(HAS__jm_Scheduler)
    #include "jm_Scheduler.h"
#endif

//Debug level
//#define DEBUG 5 
//#define DISABLE_LOOP //To debug and disable any output


#include "___main/__main_struct.h"
#include "___main/__main_trigger_struct.h"
#include "___main/__main_struct_funct.h"


#include "___main/__main_struct_limits.h"
#include "_time_struct.h"
#include "_DRIVER_STATUS/_DRIVER_STATUS_struct.h"

#include "___main/__main_I2C_struc.h"
#include "___main/__main_static.h"
#include "___main/__main_auto.h"
#include "___main/__main_register.h"
#include "___main/__main_extern.h"

#include "___template/__STORAGE_ARRAY_func.h" //testing

#define  _ControllerID   0x101 
#define  _Slave1_ID   0x103 



//#include "Active_ControllerID_0x103.h"
//#define Active_ControllerID _ControllerID 
//#define Active_ControllerID _Slave1_ID 

#include "___CONFIG/config_Active_ControllerID.h" //there kleep id of device

//#include "config_Slave_Ports_LOCAL_0x101_init.h" //there kleep config of this id device


#ifdef DEBUG
#define DPRINT(...)    Serial.print(__VA_ARGS__)
#define DPRINTLN(...)  Serial.println(__VA_ARGS__)
#define DRINTF(...)    Serial.print(F(__VA_ARGS__))
#define DPRINTLNF(...) Serial.println(F(__VA_ARGS__))
        DPRINTLN("#125 [DEBUG ENABLED]");    
        //DPRINTLN(0xC0FFEEul,DEC);
        //DPRINTLN(12648430ul,HEX);
#else
#define DPRINT(...)     //blank line
#define DPRINTLN(...)   //blank line
#define DPRINTF(...)    //blank line
#define DPRINTLNF(...)  //blank line

#endif

#if Active_ControllerID == 0x101 
     #include "___CONFIG/0x101/config_Active_ControllerID_0x101.h"
#endif


#if Active_ControllerID == 0x103 
    #include "___CONFIG/0x103/config_Active_ControllerID_0x103.h"  //there kleep config of this id device
#endif





#if defined(HAS_TFT_ILI9163C)
    #include "_TFT_ILI9163C_config.h"
#endif
#include "_DISPLAY_struct.h"
#include "_Port_ID_sruct.h"

#include "_TASK_TYPES_struct.h"
#include "_Slave_Ports_Status_QUEUE_struct.h"
//#include "Slave_Ports_Status_QUEUE.h"


#include "_I2C_driver_Adafruit_PWMServoDriver/_I2C_driver_Adafruit_PWMServoDriver_struct.h"


#if defined(HAS_ROTTARY_SW)
 #include "_ROTTARY_SW/_ROTTARY_SW_config.h"
#endif



#if defined(HAS_I2C_driver_Adafruit_PWMServoDriver)
 #include "_I2C_driver_Adafruit_PWMServoDriver/_I2C_driver_Adafruit_PWMServoDriver_config.h"
#endif

#if defined(HAS_ROTTARY_SW)
    #include "_ROTTARY_SW/_ROTTARY_SW_struct.h"
#endif

#include "Queue.h"
//#include "TPQ.h"
 Queue<int> _Slave_Ports_queue = Queue<int>(ARDUINO_ARRAY_INDEX_LIMIT_QUEUE);
 

 #if Active_ControllerID == _ControllerID 
    String lcdPattern = "s" ;
   
 #endif
 #if Active_ControllerID == _Slave1_ID 
    String lcdPattern = "." ;
    
 #endif

//BEGIN 1602
#if defined(HAS_LCD1602)
  #include <LiquidCrystal.h>
  // initialize the library with the numbers of the interface pins
  //LiquidCrystal lcd(4, 6, 10, 11, 12, 13);
  //LiquidCrystal lcd(4, 6, 53, 51, 50, 52  );
  #include "_LCD1602_struct.h"
 // #include "_LCD1602_init.h"
#endif


//#if defined(HAS_TFT_ILI9163C)
  #include "_TFT_ILI9163C_struct.h"
//#endif


#if defined(HAS__PCINT_setup)
    #include "_PCINT/_PCINT_struct.h"
#endif


//BEGIN CAN


#include "_CAN_init.h"
//EOF CAN





 //REMOTE PORTS DEFINITIONS
 #include "_PortTypes_struct.h"
 #include "_PortStates_struct.h"
 #include "_Port_Exp_state_ttl_struct.h"
 #include "_Port_Broadcast_state_struct.h"
 #include "_Port_I2C_driver_struct.h"
 #include "_Slave_Ports_Status_struct.h"
 #include "_Slave_Ports_Protocol_CAN_struct.h"
 
 #if defined(HAS_TFT_ILI9163C)
  #include "_TFT_ILI9163C_func.h"
 #endif   



#if defined(HAS_I2C_driver_Adafruit_PWMServoDriver)
    #include "_I2C_driver_Adafruit_PWMServoDriver/_I2C_driver_Adafruit_PWMServoDriver_func.h"
#endif
#include "_TASK_TYPES_func.h"
#include "_Slave_Ports_Status_QUEUE_add_func.h"
#include "_DISPLAY_add_record_func.h"
#include "_DISPLAY_func.h"

#if defined(HAS_LCD1602)
  #include "_LCD1602_func.h"
  //#include "_LCD1602_init.h"
#endif





#if defined(HAS_ROTTARY_SW)
 #include "_ROTTARY_SW/_ROTTARY_SW_func.h"
#endif

#include "_time_func.h"

#include "_Slave_Ports_ttl_decrement_func.h"
#include "_Slave_Ports_broadcast_func.h"
#include "_Slave_Ports_I2C_func.h"

#include "_DISPLAY_queue_pop_func.h"
#include "_Slave_Ports_Status_QUEUE_func.h"

#include "_Slave_Ports_Protocol_CAN_func.h"
#include "_Slave_Ports_Status_func.h"



  #include "_Slave_Ports.h"
 // #include "_Slave_Ports_ttl_decrement_POP.h"
  // #define _CAN_P_0x102_PWM0x00_0 { _Slave1_ID , "PWM", 0x00, 0 } 
   //#define _CAN_P_0x102_PWMServoDriver0x40
   
    // #define   Adafruit_PWMServoDriver pwm1 = Adafruit_PWMServoDriver();
  //    Adafruit_PWMServoDriver pwm1 = Adafruit_PWMServoDriver(0x40);


// #define __CSpin 53 // 10 //  chip select
 
 
 
#if defined(HAS_LCD1602)
  #include "_LCD1602_init.h"
#endif

#if defined(HAS_TFT_ILI9163C)
  #include "_TFT_ILI9163C_init.h"
#endif

 
#include "_DISPLAY_init.h"


  

#if defined(HAS_ROTTARY_SW)
 #include "_ROTTARY_SW/_ROTTARY_SW_init.h"
#endif



#if defined(HAS__PCINT_setup)
    #include "_PCINT/_PCINT_init.h"
#endif

#include "___CONFIG/config_Slave_Ports_LOCAL_init.h"


#if Active_ControllerID == 0x101 
     #include "___CONFIG/0x101/config_Slave_Ports_LOCAL_0x101_init.h"
#endif


#if Active_ControllerID == 0x103 
    #include "___CONFIG/0x103/config_Slave_Ports_LOCAL_0x103_init.h"
#endif


#if defined(HAS_I2C_driver_Adafruit_PWMServoDriver)
 #include "_I2C_driver_Adafruit_PWMServoDriver/_I2C_driver_Adafruit_PWMServoDriver_init.h"
#endif




#include "___main/__main_init.h"

 #ifdef DISABLE_LOOP 
        #include "___DEBUG/___DEBUG_DISABLE_INIT.h"
    #endif







void setup() {  //REMEMBER NOT INITIALIZE ANY VARIABLES OR ARRAYS
    Serial.begin(115200);
    
#ifdef DISABLE_LOOP || DEBUG
         Serial.println("#329 Serial.begin(115200)");
#endif


//    Serial.begin(9600);
//    Serial.println("#233 setup" );
// _LCD_print_queue.push(1);
// _LCD_print_queue.push(2);
// _LCD_print_queue.push(3);

//String character = "Geas";
//char b = abc.charAt(0); 
//int b_ascii_value = b;

 // LCD_print_background_add( _LCD_print_buffors,            0,           0,           0,              "W",              5000,              6000);
 // LCD_print_background_add( _LCD_print_buffors,            1,           0,           0,              "H",              5000,              6000);
 // LCD_print_background_add( _LCD_print_buffors,            2,           0,           0,              "W",              5000,              6000);
 // LCD_print_background_add( _LCD_print_buffors,            3,           0,           0,              "K",              5000,              6000);

 
//todo PCINT service
#ifdef DISABLE_LOOP || DEBUG
         Serial.println("#375 will include ___main/__main_I2C_setup.h");
#endif
#include "___main/__main_I2C_setup.h"


#if defined(HAS__PCINT_setup)
    #include "_PCINT/_PCINT_setup.h" //empty
#endif


#if defined(HAS_ROTTARY_SW)
 #include "_ROTTARY_SW/_ROTTARY_SW_setup.h"  //Attach interrupts
#endif


/* TODO
 String LCDarray1="CAN_1602_LCD           ";  //the string to print onthe LCD
 String LCDarray2="Testing id   ";  //the string to print onthe LCD
 LCDarray2.concat(String(Active_ControllerID, HEX) ) ;
 */


#if defined(HAS_I2C_driver_Adafruit_PWMServoDriver)        
            #ifdef DISABLE_LOOP || DEBUG || DEBUG_I2C_driver_Adafruit_PWMServoDriver
                     Serial.println("#401 will include /_I2C_driver_Adafruit_PWMServoDriver_setup.h");
            #endif
    
         #include "_I2C_driver_Adafruit_PWMServoDriver/_I2C_driver_Adafruit_PWMServoDriver_setup.h"
#endif
  
  // put your setup code here, to run once:
  #if defined(HAS_LCD1602)
   #include "_LCD1602_setup.h"
  #endif

  #if defined(HAS_TFT_ILI9163C)
    #include "_TFT_ILI9163C_setup.h"
  #endif 
 
  //BEGIN CAN
  #include "_CAN_setup.h"
 
   #if defined(HAS_LCD1602) 
   /* todo 
      LCDarray1 = "loop.... ";
      LCDarray2 = "....";
     LCD_print(LCDarray1, LCDarray2, LCDtim/10);
     */
    #endif



    #ifndef DISABLE_LOOP 
     #include "___main/__main_setup.h"
    #endif

 #ifdef DISABLE_LOOP 
        #include "___DEBUG/___DEBUG_DISABLE_SETUP.h"
    #endif



}

    //#if Active_ControllerID == _ControllerID
     // byte data[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
    //#endif

  //String LCDarray1 ;
  //String LCDarray2 ;


  unsigned long time;
  
                
                ARDUINO_LOOP_LATENCY_T ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END( ARDUINO_LOOP_LATENCY_T 
                        ARDUINO_LOOP_LATENCY__MAIN_END_A)  {
                    static ARDUINO_LOOP_LATENCY_COUNTER_T  ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A = ARDUINO_LOOP_LATENCY__MAIN_END_A;
                    
                    if(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A == 0 ) {
                        ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A = ARDUINO_LOOP_LATENCY__MAIN_END_A;
                          #ifdef DEBUG
                          Serial.print("] COUNTER__MAIN_END_A["); Serial.print(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A); Serial.print("] C["); Serial.print(ARDUINO_LOOP_LATENCY__MAIN_END_A); Serial.println("] ");
                          #endif
                    } else {
                        return ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A-- ;
                    }
                }
                
                                
                ARDUINO_LOOP_LATENCY_T ARDUINO_LOOP_LATENCY_COUNTER__MAIN( ARDUINO_LOOP_LATENCY_T 
                        ARDUINO_LOOP_LATENCY__MAIN_A)  {
                    static ARDUINO_LOOP_LATENCY_COUNTER_T  ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A = ARDUINO_LOOP_LATENCY__MAIN_A;
                    
                    if(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A == 0 ) {
                         #ifdef DEBUG
                         Serial.print("] COUNTER__MAIN_A["); Serial.print(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A); Serial.print("] C["); Serial.print(ARDUINO_LOOP_LATENCY__MAIN_A); Serial.println("] ");
                         #endif 
                        ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A = ARDUINO_LOOP_LATENCY__MAIN_A;
                    } else {
                        return ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A-- ;
                    }
                }


void loop() {


#include "___loop/___loop_init.h"
 
#if defined(HAS__PCINT_setup)
  #include "_PCINT/_PCINT_loop.h"
#endif 

 
 
#if defined(HAS_ROTTARY_SW)
    #include "_ROTTARY_SW/_ROTTARY_SW_loop.h"
#endif
 

  time = millis();

    #ifdef DISABLE_LOOP 
        #include "___DEBUG/___DEBUG_DISABLE_LOOP.h"
    #endif
    #include "___loop/__main_loop_top.h"
    
    
    
    
    if(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END(ARDUINO_LOOP_LATENCY__MAIN_END_A) <= ARDUINO_LOOP_LATENCY_COUNTER_INIT ) {
        #ifdef DEBUG
            #ifndef DISABLE_LOOP            
                if(DEBUG_ACTION_TRIG == 1)                            Serial.print("] Time: " );   Serial.println(time);
                 
            #endif
        #endif 
        if(DEBUG_ACTION_TRIG == 1 or (time % 100000 == 0)) {
            Serial.print("Time: " );   Serial.println(time);
        }
            #ifndef DISABLE_LOOP
                if(DEBUG_ACTION_TRIG == 1) {
                      #ifdef DEBUG
                      Serial.print("#331_L1 main loop top   ARDUINO_FUNCT_INIT_RESULT__Slave_Ports_LOCAL_init  ");
                      Serial.println(ARDUINO_FUNCT_INIT_RESULT__Slave_Ports_LOCAL_init);
                        Serial.print("#331_L2 main loop top ARDUINO_FUNCT_INIT_RESULT__Slave_Ports_LOCAL_init=[");
                           Serial.println(ARDUINO_FUNCT_INIT_RESULT__Slave_Ports_LOCAL_init);
                           Serial.print("   true[");  Serial.print(true); Serial.print("]   false[");  Serial.print(false);
                           Serial.println("] ");  
                       #endif
               }
               
               #ifdef DEBUG_DISPLAY
               
                Serial.print("#532 Will  TODO bug when too many mesgs to queue ..DISPLAY_pos_seq_T[");
                     Serial.print(DISPLAY_pos_seq_A_NEXT  , BIN);  Serial.print("]+[ ");    Serial.print(DISPLAY_pos_seq_A_IMMEDIATE  , BIN); Serial.print("]  ==[ "); Serial.print(DISPLAY_pos_seq_A_NEXT | DISPLAY_pos_seq_A_IMMEDIATE  , BIN);
                     Serial.print("]  DISPLAY_TARGET_T 128["); Serial.print(DISPLAY_TARGET_DISPLAY128, BIN);Serial.print("]  bin[");
                     Serial.println("]   ");
               #endif 
               
               Slave_Ports_Status__DISPLAY_TARGET(
                     Slave_Ports_Status_A ,
                     Slave_Ports_Status_T_ARDUINO_ATTR_ARRAY_A,
                      0 ,
                       DISPLAY_A ,
                         DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
                         DISPLAY_PHYSICAL_CHAR_A, 
                    DISPLAY_pos_seq_A_NEXT | DISPLAY_pos_seq_A_IMMEDIATE ,
                    "PORTS:",
                    DISPLAY_TARGET_DISPLAY128,
                   millis(),
                    millis() + ARDUINO_time_seq_id_A_INCREMENT
                     //queue
                    ,Slave_Ports_Status_QUEUE_A, Slave_Ports_Status_QUEUE_T_ARDUINO_ATTR_ARRAY_A ,
                    TASK_TYPE_T__EMPTY__JUST_PASSED_ARG__,
                    TASK_PORT_ASSOC_EMPTY
                 );
              #else 
                
                #include "___DEBUG/___DEBUG_DISABLE_LOOP_MAIN_A.h"
              #endif
}
 // Serial.println(time);
      #include "___loop/_SlaveID_loop1.h" //todo PCINT
      #include "___loop/_ControllerID_loop1.h"  //todo make default
  
  #include "___loop/__main_loop_end.h"
  // DISPLAY_DEV.setCursor(10,10);
  //   DISPLAY_DEV.print(" Test307");
  /*
  DISPLAY__print_ANY(
                    DISPLAY_T_ARDUINO_ATTR_ARRAY_A , 
                    DISPLAY_PHYSICAL_CHAR_A,
                    DISPLAY_pos_seq_A_NEXT,
                    "123456789012345678901234567890" 
        );     */
        
  delay(10);
  if(DEBUG_ACTION_TRIG != DEBUG_LAST_ACTION_TRIG)   {
        Serial.print("#534   DEBUG_ACTION_TRIG[");Serial.print(DEBUG_ACTION_TRIG);Serial.print("] "); Serial.print("]  LAST_DEBUG_ACTION_TRIG[");Serial.print(DEBUG_LAST_ACTION_TRIG);Serial.println("] ");
     //   Serial.print("] COUNTER__MAIN_A["); Serial.print(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_A);
     //   Serial.print("] COUNTER__MAIN_END_A["); Serial.print(ARDUINO_LOOP_LATENCY_COUNTER__MAIN_END_A);
  }
  DEBUG_LAST_ACTION_TRIG = DEBUG_ACTION_TRIG ;
  
}



#include "_PCINT/_PCINT_func_loop.h" //todo empty implement display etc
#include "_Slave_Ports_func_loop.h" //todo implement