Stepper component with virtual axis (0-360.0° or 0-3600 steps)

[fox244243904]

Describe your idea

A stepper component without GPIO outputs. Like a real Servo system =)

• Can run in a endless loop until stop ( lambda: id(my_virtual_stepper).set_target(id(my_virtual_stepper).current_position) )
• Endless loop for example 0-360.0° or 0-3600 steps.
• With id(my_virtual_stepper).current_position it set a real stepper motor to a position (maybe already possible)

Why is this exciting?

• Only for testing how good can I program a closed mechanical loop system
• To save GPIO outputs for even more stepper motors that follow the virtual axis

Potential use cases

Maybe it can make a good mecanical motion with multiple motors

Anything else?

(sorry my english is bad)

yaml example:

• last position is restored after power-on
• adjust to a reference (Justage)
• hardware limits switch per axis
• position feedback in set position when aborted (not real time sensor (in loop) -> maybe API too slow and stepper motors run jerkily)
• feedback "running" per axis
• LEDs and Buzzer for warning and error
• position feedback send over espnow+

esphome:
  name: esp32-s3-stepper
  friendly_name: esp32-s3-stepper
  on_boot:
    priority: 600
    then:
      - stepper.report_position:
          id: axis_1
          position: !lambda return id(axis1_save_position);
      - number.set: 
          id: axis1_pos
          value: !lambda return id(axis1_save_position);
      - stepper.report_position:
          id: axis_2
          position: !lambda return id(axis2_save_position);
      - number.set: 
          id: axis2_pos
          value: !lambda return id(axis2_save_position);
      - stepper.report_position:
          id: axis_3
          position: !lambda return id(axis3_save_position);
      - number.set: 
          id: axis3_pos
          value: !lambda return id(axis3_save_position);
      - stepper.report_position:
          id: axis_4
          position: !lambda return id(axis4_save_position);
      - number.set: 
          id: axis4_pos
          value: !lambda return id(axis4_save_position);
      - stepper.report_position:
          id: axis_5
          position: !lambda return id(axis5_save_position);
      - number.set: 
          id: axis5_pos
          value: !lambda return id(axis5_save_position);
      - if:
          condition:
            - lambda: return id(init_in_progress);
          then:
            - lambda: id(init_in_progress) = false;
            - globals.set:
                id: emergency_stop
                value: 'false'
  on_loop:
    then:
      lambda: |-
        if(id(init_in_progress) == false) {
          id(axis1_save_position) = id(axis_1).current_position;
          id(axis2_save_position) = id(axis_2).current_position;
          id(axis3_save_position) = id(axis_3).current_position;
          id(axis4_save_position) = id(axis_4).current_position;
          id(axis5_save_position) = id(axis_5).current_position;
        }
        if(id(axis1_in_motion).state == false && id(axis2_in_motion).state == false && id(axis3_in_motion).state == false && id(axis4_in_motion).state == false && id(axis5_in_motion).state == false && id(warning) == false && id(emergency_stop) == false && !(id(bta).current_option() == "Service")) {
          id(led_red).turn_off();
        }
        if(id(axis1_in_motion).state == true || id(axis2_in_motion).state == true || id(axis3_in_motion).state == true || id(axis4_in_motion).state == true || id(axis5_in_motion).state == true) {
          id(axis_in_motion) = true;
        } else {
          id(axis_in_motion) = false;
        }
        if((id(bta).current_option() == "Automatik") || (id(axis_master) >= 0 && id(axis_master) <= 10)) {
          id(led_green).turn_on();
        } else {
          id(led_green).turn_off();
        }
        if(id(bta).current_option() == "Tippen" || id(bta).current_option() == "Einrichten") {
          id(led_yellow).turn_on();
        } else {
          id(led_yellow).turn_off();
        }
        if(id(bta).current_option() == "Service") {
          id(led_white).turn_on();
        } else {
          id(led_white).turn_off();
        }
        if(id(bta).current_option() == "Master") {
          if(id(axis_1).current_position >= 2048 && id(axis_master_frg)) {
            id(axis_1).report_position(0);
            id(axis_1).set_target(2048);
          }
          id(axis_master) = round(id(axis_1).current_position / 5.689); // 0-360°
        // ************************* MOTION PROGRAM ************************* //
          if(id(axis_master) == 0) {
            id(axis_2).report_position(0);
            id(axis_2).set_target(512);
            id(axis_3).report_position(0);
            id(axis_3).set_target(1024);
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
            id(axis_5).set_target(1024);
            //id(buzzer).play("demo:d=4,o=5,b=100:c,e,g,c6");
          }
          if(id(axis_master) == 20) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 40) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 60) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 80) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 90) {
            id(axis_2).report_position(0);
            id(axis_2).set_target(512);
            id(axis_3).report_position(0);
            id(axis_3).set_target(1024);
            id(axis_5).set_target(0);
          }
          if(id(axis_master) == 100) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 120) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 140) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 160) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 180) {
            id(axis_2).report_position(0);
            id(axis_2).set_target(512);
            id(axis_3).report_position(0);
            id(axis_3).set_target(1024);
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
            id(axis_5).set_target(1024);
          }
          if(id(axis_master) == 200) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 220) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 240) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 260) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 270) {
            id(axis_2).report_position(0);
            id(axis_2).set_target(512);
            id(axis_3).report_position(0);
            id(axis_3).set_target(1024);
            id(axis_5).set_target(0);
          }
          if(id(axis_master) == 280) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 300) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 320) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
          if(id(axis_master) == 340) {
            id(axis_4).report_position(0);
            id(axis_4).set_target(64);
          }
        }

esp32:
  board: esp32-s3-devkitc-1
  framework:
    type: esp-idf

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: !secret

ota:
  - platform: esphome
    password: !secret

wifi:
  ssid: !secret parents_wifi_ssid
  password: !secret parents_wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Esp32-S3-Stepper"
    password: !secret

captive_portal:

stepper:
  - platform: uln2003
    id: axis_1
    pin_a: GPIO4
    pin_b: GPIO5
    pin_c: GPIO6
    pin_d: GPIO7
    sleep_when_done: true
    max_speed: 500 steps/s
    acceleration: 500 steps/s^2
    deceleration: 500 steps/s^2
    #step_mode: WAVE_DRIVE
  
  - platform: uln2003
    id: axis_2
    pin_a: GPIO15
    pin_b: GPIO16
    pin_c: GPIO17
    pin_d: GPIO18
    sleep_when_done: true
    max_speed: 500 steps/s
    acceleration: 500 steps/s^2
    deceleration: 500 steps/s^2
    #step_mode: WAVE_DRIVE
  
  - platform: uln2003
    id: axis_3
    pin_a: GPIO9
    pin_b: GPIO10
    pin_c: GPIO11
    pin_d: GPIO12
    sleep_when_done: true
    max_speed: 500 steps/s
    acceleration: 500 steps/s^2
    deceleration: 500 steps/s^2
    #step_mode: WAVE_DRIVE

  - platform: uln2003
    id: axis_4
    pin_a: GPIO13
    pin_b: GPIO14
    pin_c: GPIO1
    pin_d: GPIO2
    sleep_when_done: true
    max_speed: 500 steps/s
    acceleration: 500 steps/s^2
    deceleration: 500 steps/s^2
    #step_mode: WAVE_DRIVE

  - platform: uln2003
    id: axis_5
    pin_a: GPIO21
    pin_b: GPIO47
    pin_c: GPIO41
    pin_d: GPIO42
    sleep_when_done: true
    max_speed: 500 steps/s
    acceleration: 500 steps/s^2
    deceleration: 500 steps/s^2
    #step_mode: WAVE_DRIVE

globals:
  - id: init_in_progress
    type: bool
    restore_value: no
    initial_value: "true"
  - id: axis1_save_position
    type: int
    restore_value: true
  - id: axis2_save_position
    type: int
    restore_value: true
  - id: axis3_save_position
    type: int
    restore_value: true
  - id: axis4_save_position
    type: int
    restore_value: true
  - id: axis5_save_position
    type: int
    restore_value: true
  - id: warning
    type: bool
    restore_value: no
  - id: emergency_stop
    type: bool
    restore_value: no
    initial_value: "true"
  - id: axis_in_motion
    type: bool
    restore_value: no
  - id: axis_master
    type: int
    restore_value: no
  - id: axis_master_frg
    type: bool
    restore_value: no

interval:
  interval: 1s
  then:
    lambda: |-
      if(!(id(axis_1).target_position == id(axis_1).current_position)) {
        id(axis1_in_motion).publish_state(true);
      } else {
        id(axis1_in_motion).publish_state(false);
      }
      if(!(id(axis_2).target_position == id(axis_2).current_position)) {
        id(axis2_in_motion).publish_state(true);
      } else {
        id(axis2_in_motion).publish_state(false);
      }
      if(!(id(axis_3).target_position == id(axis_3).current_position)) {
        id(axis3_in_motion).publish_state(true);
      } else {
        id(axis3_in_motion).publish_state(false);
      }
      if(!(id(axis_4).target_position == id(axis_4).current_position)) {
        id(axis4_in_motion).publish_state(true);
      } else {
        id(axis4_in_motion).publish_state(false);
      }
      if(!(id(axis_5).target_position == id(axis_5).current_position)) {
        id(axis5_in_motion).publish_state(true);
      } else {
        id(axis5_in_motion).publish_state(false);
      }
      // ************************* REMOTE SENSORS ************************* //
        id(master_pos_sensor).publish_state(id(axis_master));
        id(axis1_pos_sensor).publish_state(id(axis_1).current_position);
        id(axis2_pos_sensor).publish_state(id(axis_2).current_position);
        id(axis3_pos_sensor).publish_state(id(axis_3).current_position);
        id(axis4_pos_sensor).publish_state(id(axis_4).current_position);
        id(axis5_pos_sensor).publish_state(id(axis_5).current_position);

espnow:
  peers:
    - "xx:xx:xx:xx:xx:xx"  # Consumer mac address

packet_transport:
  - platform: espnow
    peer_address: "xx:xx:xx:xx:xx:xx"  # Consumer mac address
    sensors:
      - master_pos_sensor
      - axis1_pos_sensor
      - axis2_pos_sensor
      - axis3_pos_sensor
      - axis4_pos_sensor
      - axis5_pos_sensor

sensor:
  - platform: template
    id: master_pos_sensor

  - platform: template
    id: axis1_pos_sensor

  - platform: template
    id: axis2_pos_sensor

  - platform: template
    id: axis3_pos_sensor

  - platform: template
    id: axis4_pos_sensor

  - platform: template
    id: axis5_pos_sensor

select:
  - platform: template
    entity_category: config
    name: "Betriebsart"
    id: bta
    optimistic: true
    restore_value: true
    options:
      - Aus
      - Automatik
      - Tippen
      - Einrichten
      - Service
      - Master
    initial_option: Aus
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - button.press: axis1_stop
              - button.press: axis2_stop
              - button.press: axis3_stop
              - button.press: axis4_stop
              - button.press: axis5_stop
              - if:
                  condition:
                    - lambda: return id(bta).current_option() == "Master";
                  then:
                    - stepper.set_speed:
                        id: axis_1
                        speed: 100 steps/s
                    - stepper.set_acceleration:
                        id: axis_1
                        acceleration: inf
                    - stepper.set_deceleration:
                        id: axis_1
                        deceleration: inf
                  else:
                    - stepper.set_speed:
                        id: axis_1
                        speed: !lambda return (int)id(axis1_vel);
                    - stepper.set_acceleration:
                        id: axis_1
                        acceleration: !lambda return (int)id(axis1_acc);
                    - stepper.set_deceleration:
                        id: axis_1
                        deceleration: !lambda return (int)id(axis1_dec);

binary_sensor:
  - platform: template
    id: axis1_in_motion
    name: "Axis 1: In Motion"
    device_class: running
    on_press:
      then:
        - output.turn_on: led_red
    on_release:
      then:
        - if:
            condition:
              - lambda: return (id(axis2_in_motion).state == false && id(axis3_in_motion).state == false && id(axis4_in_motion).state == false && id(axis5_in_motion).state == false);
            then:
              - rtttl.play: 'two_short:d=4,o=5,b=100:16e6,16e6'

  - platform: template
    id: axis2_in_motion
    name: "Axis 2: In Motion"
    device_class: running
    on_press:
      then:
        - output.turn_on: led_red
    on_release:
      then:
        - if:
            condition:
              - lambda: return (id(axis1_in_motion).state == false && id(axis3_in_motion).state == false && id(axis4_in_motion).state == false && id(axis5_in_motion).state == false);
            then:
              - rtttl.play: 'two_short:d=4,o=5,b=100:16e6,16e6'

  - platform: template
    id: axis3_in_motion
    name: "Axis 3: In Motion"
    device_class: running
    on_press:
      then:
        - output.turn_on: led_red
    on_release:
      then:
        - if:
            condition:
              - lambda: return (id(axis1_in_motion).state == false && id(axis2_in_motion).state == false && id(axis4_in_motion).state == false && id(axis5_in_motion).state == false);
            then:
              - rtttl.play: 'two_short:d=4,o=5,b=100:16e6,16e6'

  - platform: template
    id: axis4_in_motion
    name: "Axis 4: In Motion"
    device_class: running
    on_press:
      then:
        - output.turn_on: led_red
    on_release:
      then:
        - if:
            condition:
              - lambda: return (id(axis1_in_motion).state == false && id(axis2_in_motion).state == false && id(axis3_in_motion).state == false && id(axis5_in_motion).state == false);
            then:
              - rtttl.play: 'two_short:d=4,o=5,b=100:16e6,16e6'

  - platform: template
    id: axis5_in_motion
    name: "Axis 5: In Motion"
    device_class: running
    on_press:
      then:
        - output.turn_on: led_red
    on_release:
      then:
        - if:
            condition:
              - lambda: return (id(axis1_in_motion).state == false && id(axis2_in_motion).state == false && id(axis3_in_motion).state == false && id(axis4_in_motion).state == false);
            then:
              - rtttl.play: 'two_short:d=4,o=5,b=100:16e6,16e6'

#  - platform: gpio
#    id: axis1_hw_limit
#    name: "Axis 1: Hardware limit"
#    pin: GPIO8
#    interrupt_type: RISING  # Only detect low-to-high transitions
#    on_state:
#      then:
#        - button.press: axis1_stop

#  - platform: gpio
#    id: axis2_hw_limit
#    name: "Axis 2: Hardware limit"
#    pin: GPIO3
#    interrupt_type: RISING  # Only detect low-to-high transitions
#    on_state:
#      then:
#        - button.press: axis2_stop

#  - platform: gpio
#    id: axis3_hw_limit
#    name: "Axis 3: Hardware limit"
#    pin: GPIO46
#    interrupt_type: RISING  # Only detect low-to-high transitions
#    on_state:
#      then:
#        - button.press: axis3_stop

#  - platform: gpio
#    id: axis4_hw_limit
#    name: "Axis 4: Hardware limit"
#    pin:
#      number: GPIO43
#      inverted: true
#    interrupt_type: RISING  # Only detect low-to-high transitions
#    on_state:
#      then:
#        - button.press: axis4_stop

#  - platform: gpio
#    id: axis5_hw_limit
#    name: "Axis 5: Hardware limit"
#    pin:
#      number: GPIO44
#      inverted: true
#    interrupt_type: RISING  # Only detect low-to-high transitions
#    on_state:
#      then:
#        - button.press: axis5_stop

button:
  - platform: template
    name: "Axis Master: Start"
    id: axis_start
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(emergency_stop) == false && id(bta).current_option() == "Master");
            then:
              - if:
                  condition:
                    - lambda: return id(axis_in_motion) == false;
                  then:
                    - globals.set:
                        id: warning
                        value: 'true'
                    - output.turn_on: led_red
                    - rtttl.play: 'long:d=1,o=5,b=100:e6'
                    - delay: 2s
              - globals.set:
                  id: axis_master_frg
                  value: 'true'
              - stepper.set_target:
                  id: axis_1
                  target: 2048
              - delay: 2s
              - globals.set:
                  id: warning
                  value: 'false'

  - platform: template
    name: "Axis Master: Stop"
    id: axis_stop_1
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(bta).current_option() == "Master" && id(axis1_in_motion).state);
            then:
              - globals.set:
                  id: axis_master_frg
                  value: 'false'
              - number.set:
                  id: axis1_pos
                  value: !lambda return id(axis_1).current_position;

  - platform: template
    name: "Axis Master: 0° Stop"
    id: axis_stop_2
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(bta).current_option() == "Master" && id(axis1_in_motion).state);
            then:
              - globals.set:
                  id: axis_master_frg
                  value: 'false'

  - platform: template
    name: "Axis 1: Justage (Service)"
    id: axis1_home
    entity_category: config
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(axis1_in_motion).state == false && id(bta).current_option() == "Service");
            then:
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - stepper.report_position:
                  id: axis_1
                  position: 0
              - number.set: 
                  id: axis1_pos
                  value: 0
              - rtttl.play: 'scale_up:d=32,o=5,b=100:c,c#,d#,e,f#,g#,a#,b'

  - platform: template
    name: "Axis 2: Justage (Service)"
    id: axis2_home
    entity_category: config
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(axis2_in_motion).state == false && id(bta).current_option() == "Service");;
            then:
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - stepper.report_position:
                  id: axis_2
                  position: 0
              - number.set: 
                  id: axis2_pos
                  value: 0
              - rtttl.play: 'scale_up:d=32,o=5,b=100:c,c#,d#,e,f#,g#,a#,b'

  - platform: template
    name: "Axis 3: Justage (Service)"
    id: axis3_home
    entity_category: config
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(axis3_in_motion).state == false && id(bta).current_option() == "Service");
            then:
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - stepper.report_position:
                  id: axis_3
                  position: 0
              - number.set: 
                  id: axis3_pos
                  value: 0
              - rtttl.play: 'scale_up:d=32,o=5,b=100:c,c#,d#,e,f#,g#,a#,b'

  - platform: template
    name: "Axis 4: Justage (Service)"
    id: axis4_home
    entity_category: config
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(axis4_in_motion).state == false && id(bta).current_option() == "Service");
            then:
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - stepper.report_position:
                  id: axis_4
                  position: 0
              - number.set: 
                  id: axis4_pos
                  value: 0
              - rtttl.play: 'scale_up:d=32,o=5,b=100:c,c#,d#,e,f#,g#,a#,b'

  - platform: template
    name: "Axis 5: Justage (Service)"
    entity_category: config
    id: axis5_home
    on_press:
      then:
        - if:
            condition:
              - lambda: return (id(axis5_in_motion).state == false && id(bta).current_option() == "Service");
            then:
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - stepper.report_position:
                  id: axis_5
                  position: 0
              - number.set: 
                  id: axis5_pos
                  value: 0
              - rtttl.play: 'scale_up:d=32,o=5,b=100:c,c#,d#,e,f#,g#,a#,b'

  - platform: template
    name: "Axis 1: E-Stop"
    id: axis1_stop
    on_press:
      then:
        - if:
            condition:
              - lambda: return id(axis1_in_motion).state;
            then:
              - logger.log: "Axis 1: E-Stop"
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - number.set:
                  id: axis1_pos
                  value: !lambda return id(axis_1).current_position;
              - rtttl.play: 'siren:d=8,o=5,b=100:d,e,d,e,d,e,d,e'

  - platform: template
    name: "Axis 2: E-Stop"
    id: axis2_stop
    on_press:
      then:
        - if:
            condition:
              - lambda: return id(axis2_in_motion).state;
            then:
              - logger.log: "Axis 2: E-Stop"
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - number.set: 
                  id: axis2_pos
                  value: !lambda return id(axis_2).current_position;
              - rtttl.play: 'siren:d=8,o=5,b=100:d,e,d,e,d,e,d,e'

  - platform: template
    name: "Axis 3: E-Stop"
    id: axis3_stop
    on_press:
      then:
        - if:
            condition:
              - lambda: return id(axis3_in_motion).state;
            then:
              - logger.log: "Axis 3: E-Stop"
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - number.set: 
                  id: axis3_pos
                  value: !lambda return id(axis_3).current_position;
              - rtttl.play: 'siren:d=8,o=5,b=100:d,e,d,e,d,e,d,e'

  - platform: template
    name: "Axis 4: E-Stop"
    id: axis4_stop
    on_press:
      then:
        - if:
            condition:
              - lambda: return id(axis4_in_motion).state;
            then:
              - logger.log: "Axis 4: E-Stop"
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - number.set: 
                  id: axis4_pos
                  value: !lambda return id(axis_4).current_position;
              - rtttl.play: 'siren:d=8,o=5,b=100:d,e,d,e,d,e,d,e'

  - platform: template
    name: "Axis 5: E-Stop"
    id: axis5_stop
    on_press:
      then:
        - if:
            condition:
              - lambda: return id(axis5_in_motion).state;
            then:
              - logger.log: "Axis 5: E-Stop"
              - globals.set:
                  id: emergency_stop
                  value: 'true'
              - number.set: 
                  id: axis5_pos
                  value: !lambda return id(axis_5).current_position;
              - rtttl.play: 'siren:d=8,o=5,b=100:d,e,d,e,d,e,d,e'

number:
  - platform: template
    name: "Axis 1: Setpos (Exec)"
    id: axis1_pos
    min_value: -30000
    max_value: 30000
    step: 1
    optimistic: true
    restore_value: true
    initial_value: 0
    unit_of_measurement: mm
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(emergency_stop) == false;
            then:
              - if:
                  condition:
                    - lambda: return id(axis_in_motion) == false;
                  then:
                    - globals.set:
                        id: warning
                        value: 'true'
                    - output.turn_on: led_red
                    - rtttl.play: 'long:d=1,o=5,b=100:e6'
                    - delay: 2s
              - stepper.set_target:
                  id: axis_1
                  target: !lambda return x;
              - delay: 2s
              - globals.set:
                  id: warning
                  value: 'false'
            else:
              - stepper.set_target:
                  id: axis_1
                  target: !lambda return x;
              - if:
                  condition:
                    - lambda: return id(init_in_progress) == false;
                  then:
                    - globals.set:
                        id: emergency_stop
                        value: 'false'

  - platform: template
    name: "Axis 2: Setpos (Exec)"
    id: axis2_pos
    min_value: -30000
    max_value: 30000
    step: 1
    optimistic: true
    restore_value: true
    initial_value: 0
    unit_of_measurement: mm
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(emergency_stop) == false;
            then:
              - if:
                  condition:
                    - lambda: return id(axis_in_motion) == false;
                  then:
                    - globals.set:
                        id: warning
                        value: 'true'
                    - output.turn_on: led_red
                    - rtttl.play: 'long:d=1,o=5,b=100:e6'
                    - delay: 2s
              - stepper.set_target:
                  id: axis_2
                  target: !lambda return x;
              - delay: 2s
              - globals.set:
                  id: warning
                  value: 'false'
            else:
              - stepper.set_target:
                  id: axis_2
                  target: !lambda return x;
              - if:
                  condition:
                    - lambda: return id(init_in_progress) == false;
                  then:
                    - globals.set:
                        id: emergency_stop
                        value: 'false'

  - platform: template
    name: "Axis 3: Setpos (Exec)"
    id: axis3_pos
    min_value: -30000
    max_value: 30000
    step: 1
    optimistic: true
    restore_value: true
    initial_value: 0
    unit_of_measurement: mm
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(emergency_stop) == false;
            then:
              - if:
                  condition:
                    - lambda: return id(axis_in_motion) == false;
                  then:
                    - globals.set:
                        id: warning
                        value: 'true'
                    - output.turn_on: led_red
                    - rtttl.play: 'long:d=1,o=5,b=100:e6'
                    - delay: 2s
              - stepper.set_target:
                  id: axis_3
                  target: !lambda return x;
              - delay: 2s
              - globals.set:
                  id: warning
                  value: 'false'
            else:
              - stepper.set_target:
                  id: axis_3
                  target: !lambda return x;
              - if:
                  condition:
                    - lambda: return id(init_in_progress) == false;
                  then:
                    - globals.set:
                        id: emergency_stop
                        value: 'false'

  - platform: template
    name: "Axis 4: Setpos (Exec)"
    id: axis4_pos
    min_value: -30000
    max_value: 30000
    step: 1
    optimistic: true
    restore_value: true
    initial_value: 0
    unit_of_measurement: mm
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(emergency_stop) == false;
            then:
              - if:
                  condition:
                    - lambda: return id(axis_in_motion) == false;
                  then:
                    - globals.set:
                        id: warning
                        value: 'true'
                    - output.turn_on: led_red
                    - rtttl.play: 'long:d=1,o=5,b=100:e6'
                    - delay: 2s
              - stepper.set_target:
                  id: axis_4
                  target: !lambda return x;
              - delay: 2s
              - globals.set:
                  id: warning
                  value: 'false'
            else:
              - stepper.set_target:
                  id: axis_4
                  target: !lambda return x;
              - if:
                  condition:
                    - lambda: return id(init_in_progress) == false;
                  then:
                    - globals.set:
                        id: emergency_stop
                        value: 'false'

  - platform: template
    name: "Axis 5: Setpos (Exec)"
    id: axis5_pos
    min_value: -30000
    max_value: 30000
    step: 1
    optimistic: true
    restore_value: true
    initial_value: 0
    unit_of_measurement: mm
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(emergency_stop) == false;
            then:
              - if:
                  condition:
                    - lambda: return id(axis_in_motion) == false;
                  then:
                    - globals.set:
                        id: warning
                        value: 'true'
                    - output.turn_on: led_red
                    - rtttl.play: 'long:d=1,o=5,b=100:e6'
                    - delay: 2s
              - stepper.set_target:
                  id: axis_5
                  target: !lambda return x;
              - delay: 2s
              - globals.set:
                  id: warning
                  value: 'false'
            else:
              - stepper.set_target:
                  id: axis_5
                  target: !lambda return x;
              - if:
                  condition:
                    - lambda: return id(init_in_progress) == false;
                  then:
                    - globals.set:
                        id: emergency_stop
                        value: 'false'

  - platform: template
    name: "Axis 1: Velocity"
    id: axis1_vel
    min_value: 0
    max_value: 500
    step: 1
    optimistic: true
    #restore_value: true
    initial_value: 400
    unit_of_measurement: steps/s
    entity_category: config
    mode: slider
    on_value:
      then:
        - stepper.set_speed:
            id: axis_1
            speed: !lambda return x;

  - platform: template
    name: "Axis 2: Velocity"
    id: axis2_vel
    min_value: 0
    max_value: 500
    step: 1
    optimistic: true
    #restore_value: true
    initial_value: 400
    unit_of_measurement: steps/s
    entity_category: config
    mode: slider
    on_value:
      then:
        - stepper.set_speed:
            id: axis_2
            speed: !lambda return x;

  - platform: template
    name: "Axis 3: Velocity"
    id: axis3_vel
    min_value: 0
    max_value: 500
    step: 1
    optimistic: true
    #restore_value: true
    initial_value: 400
    unit_of_measurement: steps/s
    entity_category: config
    mode: slider
    on_value:
      then:
        - stepper.set_speed:
            id: axis_3
            speed: !lambda return x;

  - platform: template
    name: "Axis 4: Velocity"
    id: axis4_vel
    min_value: 0
    max_value: 500
    step: 1
    optimistic: true
    #restore_value: true
    initial_value: 400
    unit_of_measurement: steps/s
    entity_category: config
    mode: slider
    on_value:
      then:
        - stepper.set_speed:
            id: axis_4
            speed: !lambda return x;

  - platform: template
    name: "Axis 5: Velocity"
    id: axis5_vel
    min_value: 0
    max_value: 500
    step: 1
    optimistic: true
    #restore_value: true
    initial_value: 400
    unit_of_measurement: steps/s
    entity_category: config
    mode: slider
    on_value:
      then:
        - stepper.set_speed:
            id: axis_5
            speed: !lambda return x;

  - platform: template
    name: "Axis 1: Acceleration"
    id: axis1_acc
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_acceleration:
                  id: axis_1
                  acceleration: !lambda return x;

  - platform: template
    name: "Axis 2: Acceleration"
    id: axis2_acc
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_acceleration:
                  id: axis_2
                  acceleration: !lambda return x;

  - platform: template
    name: "Axis 3: Acceleration"
    id: axis3_acc
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_acceleration:
                  id: axis_3
                  acceleration: !lambda return x;

  - platform: template
    name: "Axis 4: Acceleration"
    id: axis4_acc
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_acceleration:
                  id: axis_4
                  acceleration: !lambda return x;

  - platform: template
    name: "Axis 5: Acceleration"
    id: axis5_acc
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_acceleration:
                  id: axis_5
                  acceleration: !lambda return x;

  - platform: template
    name: "Axis 1: Deceleration"
    id: axis1_dec
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_deceleration:
                  id: axis_1
                  deceleration: !lambda return x;

  - platform: template
    name: "Axis 2: Deceleration"
    id: axis2_dec
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_deceleration:
                  id: axis_2
                  deceleration: !lambda return x;

  - platform: template
    name: "Axis 3: Deceleration"
    id: axis3_dec
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_deceleration:
                  id: axis_3
                  deceleration: !lambda return x;

  - platform: template
    name: "Axis 4: Deceleration"
    id: axis4_dec
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_deceleration:
                  id: axis_4
                  deceleration: !lambda return x;

  - platform: template
    name: "Axis 5: Deceleration"
    id: axis5_dec
    min_value: 100
    max_value: 1000
    step: 10
    optimistic: true
    #restore_value: true
    initial_value: 500
    unit_of_measurement: steps/s^2
    entity_category: config
    mode: slider
    on_value:
      then:
        - if:
            condition:
              - lambda: return id(init_in_progress) == false;
            then:
              - stepper.set_deceleration:
                  id: axis_5
                  deceleration: !lambda return x;

output:
  - platform: ledc
    id: rtttl_out
    pin: GPIO38
  
  - platform: gpio
    id: led_red
    pin: GPIO40

  - platform: gpio
    id: led_green
    pin: GPIO39

  - platform: gpio
    id: led_yellow
    pin: GPIO20

  - platform: gpio
    id: led_white
    pin: GPIO19

rtttl:
  output: rtttl_out
  id: buzzer
  gain: 50%

Video example:
https://github.com/user-attachments/assets/89ed6dfb-8cdf-4d7f-9824-0770c97671a9