a4988.yaml

substitutions:
  stepper_id: stepper
  controller_id: controller
  stepper_motor_id_upper: ${device_name_upper}.${stepper_id}
  stepper_motor_id: ${device_name}_${stepper_id}
  controller: ${stepper_motor_id}_${controller_id}
  
  
esphome: 
  includes: 
    - esphome-stepper/steppercontroller.h
    - esphome-stepper/stepper_modes.h
    - esphome-stepper/stepper_error.h   
  on_shutdown:
    then:
      lambda: |-
        //get_controller(id(${controller}))->disable_motor();
        get_controller(id(${controller}))->on_button_stop();

  on_boot:
    priority: -300 # Highest priority, ensures enable pin to be turned off first
    then:
      - lambda: |-
            if (id(motor_enabled) == true) {
                get_controller(id(${controller}))->enable_motor();
            }
      
stepper:
  - platform: a4988
    id: ${stepper_motor_id}
    step_pin: ${stepper_step_pin}
    dir_pin:
      number: ${stepper_dir_pin}
      inverted: ${stepper_invert_direction}  
    max_speed: "${stepper_max_speed_uncalibrated} steps/s"

    sleep_pin: ${stepper_sleep_pin} 
    acceleration: ${stepper_acceleration}
    deceleration: ${stepper_deceleration}

custom_component:
  - id: ${controller}
    lambda: |-
      auto controller = new cStepperController(${stepper_initial_speed},
                                               ${stepper_max_speed},
                                               ${stepper_acceleration},
                                               ${stepper_max_acceleration},
                                               ${stepper_deceleration},
                                               ${stepper_max_deceleration},
                                               ${stepper_initial_step_width},
                                               "${device_name}",
                                               "${stepper_id}",
                                               "${controller_id}",
                                               id(${stepper_motor_id}),
                                               id(${device_name}_proximity_home),
                                               id(${device_name}_proximity_global_home),
                                               id(${device_name}_proximity_pinion_wheel),
                                               id(${stepper_motor_id}_mode),
                                               ${stepper_update_interval_ms},
                                               ${sensor_update_interval_slow_ms},
                                               ${sensor_update_interval_mid_ms},
                                               ${sensor_update_interval_fast_ms},
                                               ${sensor_update_interval_realtime_ms},
                                               ${homing_high_speed},
                                               ${homing_mid_speed},
                                               ${homing_low_speed}
                                               );
      controller->set_component_source("custom.StepperController"); 
      App.register_component(controller); 
      return {controller}; 
        
      
  
# make sure the stepper does not run while the ota update is performed            
ota:
  on_begin:
    then:
      lambda: |-
        //get_controller(id(${controller}))->disable_motor();
        get_controller(id(${controller}))->on_button_stop();

binary_sensor:
  - platform: template
    name: "${stepper_motor_id_upper}.active"
    id: ${stepper_motor_id}_active
    lambda: |-
      return get_controller(id(${controller}))->is_active();
      
  #- platform: template
  #  name: "${stepper_motor_id_upper}.direction_forward"
  #  id: ${stepper_motor_id}_direction_forward
  #  lambda: |-
  #    return get_controller(id(${controller}))->direction_forward();
      
  - platform: template
    name: "${stepper_motor_id_upper}.homing.is_valid"
    id: ${stepper_motor_id}_homing_is_valid
    lambda: |-
      return get_controller(id(${controller}))->homing_is_valid();
  
  - platform: gpio
    name: ${device_name_upper}.proximity.global_home
    id: ${device_name}_proximity_global_home
    pin: 
      number: ${sensor_proximity_switch_global_home_pin}
      mode:
        input: true
        pullup: true
    filters:
      - delayed_on: 50ms

  - platform: gpio
    name: ${device_name_upper}.proximity.home
    id: ${device_name}_proximity_home
    pin: 
      number: ${sensor_proximity_switch_home_pin}
      mode:
        input: true
        pullup: true
    filters:
      - delayed_on: 50ms    
    on_release:
      then:
        lambda: |-
          get_controller(id(${controller}))->proximity_switch_home_pressed();
    on_press:
      then:
        lambda: |-
          get_controller(id(${controller}))->proximity_switch_home_released();
    
  - platform: gpio
    name: ${device_name_upper}.proximity.pinion_wheel
    id: ${device_name}_proximity_pinion_wheel
    pin: 
      number: ${sensor_proximity_switch_pinion_wheel_pin}
      mode:
        input: true
        pullup: true
    filters:
      - delayed_on: 50ms
    on_release:
      then:
        lambda: |-
          get_controller(id(${controller}))->proximity_switch_pinion_wheel_pressed();
    on_press:
      then:
        lambda: |-
          get_controller(id(${controller}))->proximity_switch_pinion_wheel_released();
          
globals:
  - id: motor_enabled
    type: bool
    restore_value: yes
    initial_value: "false" 
    
switch:     
          
  - platform: template
    name: ${stepper_motor_id_upper}.enable_motor
    id: ${stepper_motor_id}_enable_motor
    lambda: |-
       if (id(motor_enabled) == true)
         return true;
       else
         return false;
    #lambda: |-
    #  return get_controller(id(${controller}))->motor_enabled();
    turn_on_action:
      - lambda: |- 
          get_controller(id(${controller}))->enable_motor();
          id(motor_enabled) = true;
    turn_off_action:
      - lambda: |- 
          get_controller(id(${controller}))->disable_motor();
          id(motor_enabled) = false;

  - platform: template
    name: ${stepper_motor_id_upper}.start_automation
    id: ${stepper_motor_id}_start_automation
    lambda: |-
      if(get_controller(id(${controller}))->automation_mode() != AUTOMATION_MODE_OFF)
      {
         return true;   
      }else
      {
        return false;
      }
    turn_on_action:
      - lambda: |- 
          get_controller(id(${controller}))->start_automation();
    turn_off_action:
      - lambda: |- 
          get_controller(id(${controller}))->stop_automation();
        
      
button:
  - platform: template
    name: ${stepper_motor_id_upper}.start_global_homing
    id: ${stepper_motor_id}_start_global_homing
    on_press:
      lambda: |-
        get_controller(id(${controller}))->start_global_homing();
  
  - platform: template
    name: ${stepper_motor_id_upper}.start_local_homing
    id: ${stepper_motor_id}_start_local_homing
    on_press:
      lambda: |-
        get_controller(id(${controller}))->start_local_homing();
        
  - platform: template
    name: ${stepper_motor_id_upper}.start_rangeestimation
    id: ${stepper_motor_id}_start_rangeestimation
    on_press:
      lambda: |-
        get_controller(id(${controller}))->start_rangeestimation(); 
        
  - platform: template
    name: ${stepper_motor_id_upper}.stop
    id: ${stepper_motor_id}_stop
    on_press:
      lambda: |-
        get_controller(id(${controller}))->on_button_stop();

  
  - platform: template
    name: ${stepper_motor_id_upper}.pause
    id: ${stepper_motor_id}_pause
    internal: "true"
    on_press:
      lambda: |-
        get_controller(id(${controller}))->pause();


  - platform: template
    name: ${stepper_motor_id_upper}.step_fw
    id: ${stepper_motor_id}_step_fw
    on_press:
      lambda: |-
        get_controller(id(${controller}))->step_forward();

      
  - platform: template
    name: ${stepper_motor_id_upper}.step_bw
    id: ${stepper_motor_id}_step_bw
    on_press:
      lambda: |-
        get_controller(id(${controller}))->step_backward();

  
  - platform: template
    name: ${stepper_motor_id_upper}.set_zero_position
    id: ${stepper_motor_id}_set_zero_position
    on_press:
      lambda: |-
        get_controller(id(${controller}))->set_current_position_to_zero();

    
  - platform: template
    name: ${stepper_motor_id_upper}.drive_fw
    id: ${stepper_motor_id}_drive_fw
    on_press:
      lambda: |-
        get_controller(id(${controller}))->start_drive_forward();


  - platform: template
    name: ${stepper_motor_id_upper}.drive_bw
    id: ${stepper_motor_id}_drive_bw
    on_press:
      lambda: |-
        get_controller(id(${controller}))->start_drive_backward();
   
   
  - platform: template
    name: ${stepper_motor_id_upper}.goto_home
    id: ${stepper_motor_id}_goto_home
    on_press:
      lambda: |-
        get_controller(id(${controller}))->goto_global_home();  
       
  - platform: template
    name: ${stepper_motor_id_upper}.find_next_home
    id: ${stepper_motor_id}_find_next_home
    on_press:
      lambda: |-
        get_controller(id(${controller}))->find_next_home(); 
  
  - platform: template
    name: ${stepper_motor_id_upper}.find_next_global_home
    id: ${stepper_motor_id}_find_next_global_home
    on_press:
      lambda: |-
        get_controller(id(${controller}))->find_next_global_home();
        
  - platform: template
    name: ${stepper_motor_id_upper}.set_homing_valid
    id: ${stepper_motor_id}_set_homing_valid
    on_press:
      lambda: |-
        get_controller(id(${controller}))->set_homing_valid();        
        
  - platform: template
    name: ${stepper_motor_id_upper}.goto_requested_target_position
    id: ${stepper_motor_id}_goto_requested_target_position
    on_press:
      lambda: |-
        get_controller(id(${controller}))->goto_requested_target();


  - platform: template
    name: ${stepper_motor_id_upper}.set_requested_speed
    id: ${stepper_motor_id}_set_requested_speed
    internal: true
    on_press:
      lambda: |-
        get_controller(id(${controller}))->set_speed_requested();


number:
               
  #- platform: template
  #  min_value: "-2293800"
  #  max_value: "2293800"
  #  step: "1"
  #  id: ${stepper_motor_id}_set_requested_target_position
  #  name: ${stepper_motor_id_upper}.set_requested_target_position
  #  optimistic: true
  #  mode: box
  #  restore_value : false
  #  initial_value: "0"
  #  update_interval: "10s"
  #  unit_of_measurement: "steps"
  #  on_value:
  #    - if:
  #        condition:
  #          lambda: |-
  #            return id(boot_finished);
  #        then:
  #          - lambda: |-
  #             get_controller(id(${controller}))->on_set_requested_target_position(x);
           
  - platform: template
    min_value: "-1080"
    max_value: "1080"
    step: "0.01"
    id: ${stepper_motor_id}_set_requested_target_angle
    name: ${stepper_motor_id_upper}.set_requested_target_angle
    optimistic: true
    mode: box
    restore_value : false
    initial_value: "0"
    update_interval: "10s"
    unit_of_measurement: "°"
    on_value:
      - if:
          condition:
            lambda: |-
              return id(boot_finished);
          then:
            - lambda: |-
               get_controller(id(${controller}))->on_set_requested_target_angle(x);
  
  - platform: template
    min_value: "0"
    max_value: ${stepper_max_deceleration}
    step: "1"
    id: ${stepper_motor_id}_set_deceleration
    name: ${stepper_motor_id_upper}.set_deceleration
    optimistic: true
    mode: box
    restore_value : false
    initial_value: ${stepper_deceleration}
    update_interval: "10s"
    unit_of_measurement: "steps/s^2"
    on_value:
      - if:
          condition:
            lambda: |-
              return id(boot_finished);
          then:
            - lambda: |-
               get_controller(id(${controller}))->on_set_deceleration(x);
  
  - platform: template
    min_value: "0"
    max_value: ${stepper_max_acceleration}
    step: "1"
    id: ${stepper_motor_id}_set_acceleration
    name: ${stepper_motor_id_upper}.set_acceleration
    optimistic: true
    mode: box
    restore_value : false
    initial_value: ${stepper_acceleration}
    update_interval: "10s"
    unit_of_measurement: "steps/s^2"
    on_value:
      - if:
          condition:
            lambda: |-
              return id(boot_finished);
          then:
            - lambda: |-
               get_controller(id(${controller}))->on_set_acceleration(x);
         
  - platform: template
    min_value: "0"
    max_value: ${stepper_max_speed}
    step: "1"
    id: ${stepper_motor_id}_set_speed
    name: ${stepper_motor_id_upper}.set_speed
    optimistic: true
    mode: box
    restore_value : false
    initial_value: ${stepper_initial_speed}
    update_interval: "10s"
    unit_of_measurement: "steps/s"
    on_value:
      - if:
          condition:
            lambda: |-
              return id(boot_finished);
          then:
            - lambda: |-
               get_controller(id(${controller}))->on_set_speed(x);      
     
#  - platform: template
#    min_value: "0"
#    max_value: ${stepper_max_turns_per_hour}
#    step: "0.01"
#    id: ${stepper_motor_id}_set_speed_turns_per_hour
#    name: ${stepper_motor_id_upper}.set_speed_turns_per_hour
#    optimistic: true
#    mode: box
#    restore_value : false
#    initial_value: ${stepper_initial_turns_per_hour}
#    update_interval: "10s"
#    unit_of_measurement: "turns/h"
#    on_value:
#      - if:
#          condition:
#            lambda: |-
#              return id(boot_finished);
#          then:
#            - lambda: |-
#               get_controller(id(${controller}))->on_set_speed_turns_per_hour(x);      
#     
#  - platform: template
#    min_value: "0"
#    max_value: "2293800"
#    step: "1"
#    id: ${stepper_motor_id}_set_step_width
#    name: ${stepper_motor_id_upper}.set_step_width
#    optimistic: true
#    mode: box
#    restore_value : false
#    initial_value: ${stepper_initial_step_width}
#    update_interval: "10s"
#    unit_of_measurement: "steps"
#    on_value:
#       - if:
#           condition:
#             lambda: |-
#               return id(boot_finished);
#           then:
#             - lambda: |-
#                get_controller(id(${controller}))->on_set_step_width(x);      
    
  - platform: template
    min_value: "0"
    max_value: "1080"
    step: "0.01"
    id: ${stepper_motor_id}_set_step_angle
    name: ${stepper_motor_id_upper}.set_step_angle
    optimistic: true
    mode: box
    restore_value : false
    initial_value: "15"
    update_interval: "10s"
    unit_of_measurement: "°"
    on_value:
      - if:
          condition:
            lambda: |-
              return id(boot_finished);
          then:
            - lambda: |-
               get_controller(id(${controller}))->on_set_step_angle(x);  
#   
#  - platform: template
#    min_value: "-2293758"
#    max_value: "2293758"
#    step: "1"
#    id: ${stepper_motor_id}_set_zero_position_value
#    name: ${stepper_motor_id_upper}.set_zero_position_value
#    optimistic: true
#    mode: box
#    restore_value : false
#    initial_value: "0"
#    update_interval: "10s"
#    unit_of_measurement: "steps"
#    on_value:
#      - if:
#          condition:
#            lambda: |-
#              return id(boot_finished);
#          then:
#            - lambda: |-
#               get_controller(id(${controller}))->on_set_zero_position(x);  
#   
#  - platform: template
#    min_value: "-1080.0"
#    max_value: "1080.0"
#    step: "0.01"
#    id: ${stepper_motor_id}_set_zero_angle
#    name: ${stepper_motor_id_upper}.set_zero_angle
#    optimistic: true
#    mode: box
#    restore_value : false
#    initial_value: "0.0"
#    update_interval: "10s"
#    unit_of_measurement: "°"
#    on_value:
#      - if:
#          condition:
#            lambda: |-
#              return id(boot_finished);
#          then:
#            - lambda: |-
#               get_controller(id(${controller}))->on_set_zero_angle(x); 
#