se/SE/stuff/p5_neuron/p5_neuron.ino

#include "Arduino.h"
#include <Servo.h>
Servo myservo; 



            
        #define Port7 7 //for TFT_ILI9163C_CSpin 7 
        #define Port8 8 //for TFT_ILI9163C_DCpin 8  
        #define Port9 9 //for TFT_ILI9163C__RSTpin 9
     //   #define TFT_ILI9163C_CSpin Port7 // 7 // __CSpin // 53 // 10 //  chip select
   

#include "__main_struct.h" //lite #include "___main/__main_struct.h"

#include "progmem.h"

#include "__main_struct_limits.h"
#include "_PortTypes_struct.h"
#include "_Port_Exp_state_ttl_struct.h"
#include "_Port_Broadcast_state_struct.h"
#include "_PortStates_struct.h"
#include "_Port_I2C_driver_struct.h"
#include "config_Active_ControllerID.h"
#include "config_Slave_Ports_LOCAL_config.h" //lite

#if defined(HAS_RF24)
    #include "RF24_config.h"
#endif
     
        
#if ! defined(TFT_ILI9163C_DCpin)
  #define TFT_ILI9163C_DCpin Port8 //8 // A0   data/command pin.   sometimes called DC, RS, ...
#endif

#if ! defined(TFT_ILI9163C__RSTpin)
#define TFT_ILI9163C__RSTpin Port9 //9 //reset pin.   you must connect.   (or pullup)
#endif


#include "automation_driven.submodule.struct.write_neuron.h"


    #if defined(HAS_LCD1602_I2C)
        #include <LiquidCrystal_I2C.h>
        LiquidCrystal_I2C lcd(0x27,LCD1602_DISPLAY_PHYSICAL_X_CHARS_A,LCD1602_DISPLAY_PHYSICAL_Y_CHARS_A);
    #endif
    


#if defined(HAS_TFT_ILI9163C)
   #include "_TFT_ILI9163C_config.h"
//  #include "_TFT_ILI9163C_struct.h"
    bool DISPLAY_PHYS_A_set() {
        DISPLAY_PHYS_A[0].X = 128 ; 
        DISPLAY_PHYS_A[0].Y = 128 ;
    }
    bool DISPLAY_PHYS_A_set_init = DISPLAY_PHYS_A_set();

   TFT_ILI9163C DISPLAY_DEV = TFT_ILI9163C(TFT_ILI9163C_CSpin, TFT_ILI9163C_DCpin, TFT_ILI9163C__RSTpin); //#include "_TFT_ILI9163C_func.h"
   #elif defined(HAS_TFT_HX8357)
   #include <TFT_HX8357.h>
  // #error test
   TFT_HX8357 DISPLAY_DEV = TFT_HX8357();       // Invoke custom library
   bool DISPLAY_PHYS_A_set() {
        DISPLAY_PHYS_A[0].X = 320 ; 
        DISPLAY_PHYS_A[0].Y = 240 ;
    }
    bool DISPLAY_PHYS_A_set_init = DISPLAY_PHYS_A_set();
#endif




#if defined(HAS_BH1750)
    #include <Wire.h> //BH1750 IIC Mode 
    #include <math.h> 
    int BH1750address = 0x23; //setting i2c address
    byte BH1750_buff[2];
    bool if_BH1750_Init = 0 ;
    void BH1750_Init(int address) 
        {
          Wire.beginTransmission(address);
          Wire.write(0x10);//1lx reolution 120ms
          Wire.endTransmission();
        }
        
    int BH1750_Read(int address) //
        {
          int i=0;
          Wire.beginTransmission(address);
          Wire.requestFrom(address, 2);
          while(Wire.available()) //
          {
            BH1750_buff[i] = Wire.read();  // receive one byte
            i++;
          }
          Wire.endTransmission();  
          return i;
        }
    
#endif





#if defined(HAS_W5IOKeypad)
    #include <W5IOKeypad.h>
#endif



#if defined(HAS__PCINT_setup)
    #include "_PCINT_struct.h"  //pins MYPIN1 MYPIN2 MYPIN3
#endif




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

#if defined(HAS_ROTTARY_SW)
    #include "_ROTTARY_SW_struct.h" //lite _ROTTARY_SW/
    #else
        int encoderPos = 0 ;
        int oldEncPos = 0 ;
        int triggerCount = 0 ;
        int triggerCountOld = 0 ;
#endif




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

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

//#include "config_Slave_Ports_LOCAL_init.h"
#include "automation_driven.submodule.struct.write_neuron_override.h"




#include "neuron-conf.h"


#include "config_Slave_Ports_LOCAL_neuron_config.h"  



#include "neuron_Input_func.h"
#include "neuron_Stress_func.h"
#include "neuron_Attract_func.h"
#include "neuron_PORT_to_NEURON_func.h"
#include "neuron_Resting_Potenial_func.h"



#include "_TASK_TYPES_struct.h"

bool neuron_print_ROTTARY_Coordinate_Y_SHIFT_flag = 0 ;


#include "automation_driven.submodule.struct.write_neuron.lcd_menu.h"

#include "Simulated_potential_show_lcd.h"

#include "_time_struct.h"


#if  defined(HAS_ADKeyboard)
    #include "ADKeyboard.h"
#endif


 #if defined(HAS_TFT_HX8357) || defined(HAS_TFT_ILI9163C)
    #include "neuron_print.h"
 #endif
// bool if_show_p0_neuron_title = 0 ;
#include "TASK_TYPE_T_Get_Ports_Status_INPUT_A___.h"



#include "_Slave_Ports_Status_func_add_lite.h"


#if Active_ControllerID == 0x14 
    #include "0x14/config_Slave_Ports_LOCAL_0x14_init.h"
#elif Active_ControllerID == 0x35
     #include "0x35/config_Slave_Ports_neuron_LOCAL_0x35_init.h"

#elif Active_ControllerID == 0x38
     #include "0x38/config_Slave_Ports_LOCAL_0x38_init.h"

#else
    #error not set  correct Active_ControllerID    
#endif




#if defined(HAS_W5IOKeypad)
    W5IOKeypad Keypad( W5IOKeypad_PIN_GND, W5IOKeypad_PIN_IO1, W5IOKeypad_PIN_IO2, W5IOKeypad_PIN_IO3, W5IOKeypad_PIN_IO4, W5IOKeypad_PIN_IO5 );
    int IOKey = 0;
    int IOKey_last = 0;
#endif





void action_button_input( ) {
    #if defined(HAS_W5IOKeypad)
    for(int i=0; i<20;i++) {
        lcd.setCursor(i,1);
        if(IOKey == i+1) {
        
            if(IOKey == 11) {//11 l 
                lcd_menu__action_button_input__left() ;
            } else if(IOKey == 12) { //12 up
                lcd_menu__action_button_input__up() ;
            } else if(IOKey == 13) {  //13 fire
                lcd_menu__action_button_input__toggle() ;
            } else if(IOKey == 14) { //14 dol
                lcd_menu__action_button_input__down();
            } else if(IOKey == 15) { //15 r
                lcd_menu__action_button_input__right() ;
            } else  {
                lcd.print("+");
                //NEURON_A[i].Simulated_potential = NEURON_A[i].Simulated_potential + ( action_button_input_Maximum_current * action_button_input_Time_constant ) / NEURON_A[i].Capacitance ;
              
              
              
               
             
               
                neuron_Input(i,neuron_Logic_A[0].action_button_input_Time_constant , neuron_Logic_A[0].action_button_input_Maximum_current, 0 );
                Serial.print(F(" ")); Serial.print(NEURON_A[i].Simulated_potential);
            }
        } else  lcd.print(" ");
    }
    #elif defined(HAS_ADKeyboard)
      if(IOKey == 1) {
          lcd_menu__action_button_input__right() ;
      } else if(IOKey == 2) {
           lcd_menu__action_button_input__down();
      } else if(IOKey == 3) {
          lcd_menu__action_button_input__up() ;
      } else if(IOKey == 4) {
         lcd_menu__action_button_input__left() ;
      } else if(IOKey == 5) {
          lcd_menu__action_button_input__toggle() ;
      } 
        
    #endif
}


#include "neuron_PCF8574.h"



#if defined(HAS_HCSR04)
    #include "HC-SR04.h" 
#endif



void setup() {  //REMEMBER NOT INITIALIZE ANY VARIABLES OR ARRAYS
    Serial.begin(115200);
    
    
     lcd.init();                      // Print a message to the LCD.
     lcd.backlight();
     lcd.setCursor(0,0);
    //lcd.print("debug neuron ");
    #if defined(HAS_TFT_HX8357)
      DISPLAY_DEV.init();
      DISPLAY_DEV.setRotation(1);
    #elif defined(HAS_TFT_ILI9163C)
     DISPLAY_DEV.begin();
    #endif
    
    
   
     #if defined(HAS_TFT_HX8357) || defined(HAS_TFT_ILI9163C)
     //   DISPLAY_DEV.setRotation(2);
        DISPLAY_DEV.fillScreen(BLACK);//DISPLAY_DEV.clearScreen();
        DISPLAY_DEV.setCursor(0,0);
    
      #endif

        
        #if defined(HAS__PCINT_setup)
            #include "_PCINT_setup.h" //empty
        #endif
        
        
        #if defined(HAS_ROTTARY_SW)
         #include "_ROTTARY_SW_setup.h"  //Attach interrupts //lite _ROTTARY_SW/
        #endif
    
    show_p0_neuron_title();
    /*
    pinMode(AnalogSensorLL_PIN, INPUT_PULLUP);
    pinMode(AnalogSensorLC_PIN, INPUT_PULLUP); 
    pinMode(AnalogSensorRC_PIN, INPUT_PULLUP); 
    pinMode(AnalogSensorRR_PIN, INPUT_PULLUP);
 */
 
 
    TASK_TYPE_T_Get_Ports_Status_INPUT_A___SETUP();
    
     
    
    #if defined(PWM_Servo_PIN)
        myservo.attach(PWM_Servo_PIN); 
        myservo.write(90);
    #endif   
    #if defined(HAS_HCSR04)
         pinMode(HCSR04_trigPin, OUTPUT); // Sets the trigPin as an OUTPUT
         pinMode(HCSR04_echoPin, INPUT); // Sets the echoPin as an INPUT
    #endif
    
    
    #if defined(HAS_ADKeyboard)
     //   pinMode(ADKeyboard_PIN, INPUT_PULLUP) ; 
    #endif
    
    #if defined(HAS_BH1750)
          Wire.begin();
    #endif
    
    #if defined(HAS_RF24)
        #include "RF24_setup.h"
    #endif
    
    
  //  pinMode(11, OUTPUT);
  //  pinMode(13, OUTPUT);
  //  pinMode(3, OUTPUT);
  //  pinMode(5, OUTPUT);
  //  pinMode(A7, OUTPUT);
  //  pinMode(13, OUTPUT);
  //  digitalWrite(13,LOW);
  // pinMode(A6, INPUT) ; 
 }
 
 
  
 void loop() {
 
    if(NEURON_TO_PORT_A_INDEX_NEXT > NEURON_TO_PORT_A_LIMIT) { SPFTFT2(limit,error,-321); SPFTFT2(value,error, NEURON_TO_PORT_A_INDEX_NEXT - NEURON_TO_PORT_A_LIMIT ) ;}
    if(PORT_to_NEURON_A_INDEX_NEXT > PORT_to_NEURON_A_LIMIT) { SPFTFT2(limit,error,-322); SPFTFT2(value,error, PORT_to_NEURON_A_INDEX_NEXT - PORT_to_NEURON_A_LIMIT ) ; }
     // digitalWrite(31,HIGH);
     // digitalWrite(33,HIGH);
      //SPFTFT2(level,debug,analogRead(A6));
                                               

                                            
                                             if(triggerCount != triggerCountOld) {
                                               
                                            
                                                SPFTFT2(rottary,trigger,triggerCount);
                                                   
                                                if(triggerCountOld_t < millis()) {
                                                    triggerCountOld_t = millis() + 500 ;
                                                    triggerCountOld =  triggerCount ;
                                                } else {
                                                    SPFTFTFTFT(rottary,trigger,time,bypassed);
                                                     triggerCountOld =  triggerCount ;
                                                }      
                                             
                                             }
                                 
                                       
                                        
                                        
                                        
                                        
              
             
                                        
                                        
                                        
  //  if(if_show_p0_neuron_title == 0) show_p0_neuron_title() ;
  //  Serial.print(F("R"));
   #if defined(HAS_HCSR04)
    HCSR04_input();
   #endif
  
    #if defined(HAS_RF24) and HAS_RF24 == 1
        #include "RF24_RX_loop.h"
    #endif
    neuron_PORT_to_NEURON();
    
    
    neuron_Resting_Potenial_input();
    neuron_Resting_Potenial();
    
    
  //  Serial.print(F("C"));
    Simulated_potential_show_lcd();
    
  //  Serial.print(F("P"));
   #if defined(HAS_TFT_HX8357) || defined(HAS_TFT_ILI9163C)
    neuron_print();
   #endif
    TASK_TYPE_T_Get_Ports_Status_INPUT_A___LOOP();
    #if defined(HAS_W5IOKeypad)
     //   Serial.print(F("K"));
       IOKey=Keypad.ReadButtons();
         if(IOKey == 0) {
            IOKey_last = IOKey ;
         } else if(IOKey_last == IOKey and IOKey != 0) {
            // Serial.print(F("K")); 
         } else { 
            IOKey_last = IOKey ;
            Serial.println(IOKey);
            Serial.print(F("A"));
            action_button_input();
         }
    #elif  defined(HAS_ADKeyboard)
        
        
        if(ADKeyboard_get_key_t > millis()) {
        } else if(ADKeyboard_get_key()>0 and ADKeyboard_get_key_delay_t < millis()) {
            ADKeyboard_get_key_delay_t = millis() + 100 ;
        } else {
                     IOKey=ADKeyboard_get_key();
                        if(IOKey == 0) {
                         IOKey_last = IOKey ;
                         } else if(IOKey_last == IOKey and IOKey != 0) {
                             
                         }  else { 
                             ADKeyboard_get_key_t = millis() + 300 ;
                             IOKey_last = IOKey ;
                             Serial.println(IOKey);
                             Serial.print(F(" A "));
                             SPFT2(input,analogRead(ADKeyboard_PIN));
                             action_button_input();
                 
                 }
              }
    #endif
 }