sensor.yaml

sensor:
  - platform: template
    name: "${stepper_motor_id_upper}.position"
    id: ${stepper_motor_id}_position
    unit_of_measurement: "steps"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->current_position();
    update_interval: ${sensor_update_interval_realtime}
    
  - platform: template
    name: "${stepper_motor_id_upper}.number_of_cycles"
    id: ${stepper_motor_id}_number_of_cycles
    unit_of_measurement: ""
    state_class: "measurement"
    accuracy_decimals: "3"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->number_of_cycles();
    update_interval: ${sensor_update_interval_slow}  
  
  - platform: template
    name: "${stepper_motor_id_upper}.angle"
    id: ${stepper_motor_id}_angle
    unit_of_measurement: "°"
    state_class: "measurement"
    accuracy_decimals: "3"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->current_angle();
    update_interval: ${sensor_update_interval_fast}
  
  - platform: template
    name: "${stepper_motor_id_upper}.global_angle"
    id: ${stepper_motor_id}_global_angle
    unit_of_measurement: "°"
    state_class: "measurement"
    accuracy_decimals: "3"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->current_global_angle();
    update_interval: ${sensor_update_interval_mid}
  
  - platform: template
    name: "${stepper_motor_id_upper}.angular_velocity"
    id: ${stepper_motor_id}_angular_velocity
    unit_of_measurement: "°/s"
    state_class: "measurement"
    accuracy_decimals: "3"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->current_angular_velocity();
    update_interval: ${sensor_update_interval_fast}
  
  - platform: template
    name: "${stepper_motor_id_upper}.turns_per_hour"
    id: ${stepper_motor_id}_turns_per_hour
    unit_of_measurement: "turns/h"
    state_class: "measurement"
    accuracy_decimals: "3"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->current_turns_per_hour();
    update_interval: ${sensor_update_interval_fast}
    
  - platform: template
    name: "${stepper_motor_id_upper}.target_position"
    id: ${stepper_motor_id}_target_position
    unit_of_measurement: "steps"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${stepper_motor_id}_controller))->target_position();
    update_interval: ${sensor_update_interval_fast}
    
  - platform: template
    name: "${stepper_motor_id_upper}.speed"
    id: ${stepper_motor_id}_speed
    unit_of_measurement: "steps/s"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->speed();
    update_interval: ${sensor_update_interval_mid}
    
  - platform: template
    name: "${stepper_motor_id_upper}.acceleration"
    id: ${stepper_motor_id}_acceleration
    unit_of_measurement: "steps/s^2"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->acceleration();
    update_interval: ${sensor_update_interval_mid}
    
  - platform: template
    name: "${stepper_motor_id_upper}.deceleration"
    id: ${stepper_motor_id}_deceleration
    unit_of_measurement: "steps/s^2"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->deceleration();
    update_interval: ${sensor_update_interval_mid}
   
  - platform: template
    name: "${stepper_motor_id_upper}.step_width"
    id: ${stepper_motor_id}_step_width
    unit_of_measurement: "steps"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->step_width();
    update_interval: ${sensor_update_interval_fast}   
  
  - platform: template
    name: "${stepper_motor_id_upper}.step_angle"
    id: ${stepper_motor_id}_step_angle
    unit_of_measurement: "°"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->step_angle();
    update_interval: ${sensor_update_interval_fast}   
    
  - platform: template
    name: "${stepper_motor_id_upper}.measured_full_turn_steps"
    id: ${stepper_motor_id}_measured_full_turn_steps
    unit_of_measurement: "steps"
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->measured_full_turn_steps();
    update_interval: ${sensor_update_interval_mid}   
    
  - platform: template
    name: "${stepper_motor_id_upper}.mode"
    id: ${stepper_motor_id}_mode
    state_class: ""
    lambda: |-
      return get_controller(id(${controller}))->stepper_mode();
    update_interval: ${sensor_update_interval_fast} 
    
  - platform: template
    name: "${stepper_motor_id_upper}.automation_mode"
    id: ${stepper_motor_id}_automation_mode
    state_class: ""
    lambda: |-
      return get_controller(id(${controller}))->automation_mode();
    update_interval: ${sensor_update_interval_fast}   
    
  - platform: template
    name: "${stepper_motor_id_upper}.error.code"
    id: ${stepper_motor_id}_error_code
    state_class: ""
    lambda: |-
      return get_controller(id(${controller}))->stepper_error();
    update_interval: ${sensor_update_interval_fast} 
    
  - platform: template
    name: "${device_name_upper}.proximity_switch.pinion_wheel_count"
    id: ${device_name}_proximity_switch_pinion_wheel_count
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->pinion_wheel_count();
    update_interval: ${sensor_update_interval_fast}
  
  - platform: template
    name: "${device_name_upper}.proximity_switch.expected_pinion_wheel_count"
    id: ${device_name}_proximity_switch_expected_pinion_wheel_count
    state_class: "measurement"
    lambda: |-
      return get_controller(id(${controller}))->expected_pinion_wheel_count();
    update_interval: ${sensor_update_interval_fast}
   
  - platform: template
    name: "${stepper_motor_id_upper}.homing.difference"
    id: ${stepper_motor_id}_homing_difference
    state_class: "measurement"
    unit_of_measurement: "steps"
    lambda: |-
      return get_controller(id(${controller}))->homing_difference();
    update_interval: ${sensor_update_interval_fast}   
    
  - platform: template
    name: "${stepper_motor_id_upper}.plant_gear_rotation_angle"
    id: ${stepper_motor_id}_plant_gear_rotation_angle
    state_class: "measurement"
    unit_of_measurement: "°"
    lambda: |-
      return get_controller(id(${controller}))->plant_gear_rotation_angle();
    update_interval: ${sensor_update_interval_fast}  

  - platform: template
    name: ${stepper_motor_id_upper}.cam1.plant
    id: ${stepper_motor_id}_cam1_plant
    update_interval: 1s
    lambda: |-
      float tmp_angle = id(${stepper_motor_id}_angle).state;
      float angle = tmp_angle / 360.0;
      angle = angle - (int)angle;
      angle = angle * 360.0;
      
      
      if ((angle >= 330.0 && 
          angle < 360.0 )||
          (angle >= 0.0 && 
          angle < 30.0)) 
      {
        return 1;
      } else if (angle >= 30.0 && 
                 angle < 90.0) 
      {
        return 6;
      } else if (angle >= 90.0 && 
                 angle < 150.0) 
      {
        return 5;
      } else if (angle >= 150.0 && 
                 angle < 210.0) 
      {
        return 4;
      } else if (angle >= 210.0 && 
                 angle < 270.0) 
      {
        return 3;
      } else if (angle >= 270.0 && 
                 angle < 330.0) 
      {
        return 2;
      }
      else
      {
        return 0;
      }

  - platform: template
    name: ${stepper_motor_id_upper}.cam2.plant
    id: ${stepper_motor_id}_cam2_plant
    update_interval: 1s
    lambda: |-
      float tmp_angle = id(${stepper_motor_id}_angle).state;
      float angle = tmp_angle / 360.0;
      angle = angle - (int)angle;
      angle = angle * 360.0;
      
      
      if ((angle >= 330.0 && 
          angle < 360.0 )||
          (angle >= 0.0 && 
          angle < 30.0)) 
      {
        return 2;
      } else if (angle >= 30.0 && 
                 angle < 90.0) 
      {
        return 1;
      } else if (angle >= 90.0 && 
                 angle < 150.0) 
      {
        return 6;
      } else if (angle >= 150.0 && 
                 angle < 210.0) 
      {
        return 5;
      } else if (angle >= 210.0 && 
                 angle < 270.0) 
      {
        return 4;
      } else if (angle >= 270.0 && 
                 angle < 330.0) 
      {
        return 3;
      }
      else
      {
        return 0;
      }
      
  - platform: template
    name: ${stepper_motor_id_upper}.cam3.plant
    id: ${stepper_motor_id}_cam3_plant
    update_interval: 1s
    lambda: |-
      float tmp_angle = id(${stepper_motor_id}_angle).state;
      float angle = tmp_angle / 360.0;
      angle = angle - (int)angle;
      angle = angle * 360.0;
      
      
      if ((angle >= 330.0 && 
          angle < 360.0 )||
          (angle >= 0.0 && 
          angle < 30.0)) 
      {
        return 3;
      } else if (angle >= 30.0 && 
                 angle < 90.0) 
      {
        return 2;
      } else if (angle >= 90.0 && 
                 angle < 150.0) 
      {
        return 1;
      } else if (angle >= 150.0 && 
                 angle < 210.0) 
      {
        return 6;
      } else if (angle >= 210.0 && 
                 angle < 270.0) 
      {
        return 5;
      } else if (angle >= 270.0 && 
                 angle < 330.0) 
      {
        return 4;
      }
      else
      {
        return 0;
      }
  
  - platform: template
    name: ${stepper_motor_id_upper}.cam4.plant
    id: ${stepper_motor_id}_cam4_plant
    update_interval: 1s
    lambda: |-
      float tmp_angle = id(${stepper_motor_id}_angle).state;
      float angle = tmp_angle / 360.0;
      angle = angle - (int)angle;
      angle = angle * 360.0;
      
      
      if ((angle >= 330.0 && 
          angle < 360.0 )||
          (angle >= 0.0 && 
          angle < 30.0)) 
      {
        return 4;
      } else if (angle >= 30.0 && 
                 angle < 90.0) 
      {
        return 3;
      } else if (angle >= 90.0 && 
                 angle < 150.0) 
      {
        return 2;
      } else if (angle >= 150.0 && 
                 angle < 210.0) 
      {
        return 1;
      } else if (angle >= 210.0 && 
                 angle < 270.0) 
      {
        return 6;
      } else if (angle >= 270.0 && 
                 angle < 330.0) 
      {
        return 5;
      }
      else
      {
        return 0;
      }

  - platform: template
    name: ${stepper_motor_id_upper}.cam5.plant
    id: ${stepper_motor_id}_cam5_plant
    update_interval: 1s
    lambda: |-
      float tmp_angle = id(${stepper_motor_id}_angle).state;
      float angle = tmp_angle / 360.0;
      angle = angle - (int)angle;
      angle = angle * 360.0;
      
      
      if ((angle >= 330.0 && 
          angle < 360.0 )||
          (angle >= 0.0 && 
          angle < 30.0)) 
      {
        return 5;
      } else if (angle >= 30.0 && 
                 angle < 90.0) 
      {
        return 4;
      } else if (angle >= 90.0 && 
                 angle < 150.0) 
      {
        return 3;
      } else if (angle >= 150.0 && 
                 angle < 210.0) 
      {
        return 2;
      } else if (angle >= 210.0 && 
                 angle < 270.0) 
      {
        return 1;
      } else if (angle >= 270.0 && 
                 angle < 330.0) 
      {
        return 6;
      }
      else
      {
        return 0;
      }

  - platform: template
    name: ${stepper_motor_id_upper}.cam6.plant
    id: ${stepper_motor_id}_cam6_plant
    update_interval: 1s
    lambda: |-
      float tmp_angle = id(${stepper_motor_id}_angle).state;
      float angle = tmp_angle / 360.0;
      angle = angle - (int)angle;
      angle = angle * 360.0;
      
      
      if ((angle >= 330.0 && 
          angle < 360.0 )||
          (angle >= 0.0 && 
          angle < 30.0)) 
      {
        return 6;
      } else if (angle >= 30.0 && 
                 angle < 90.0) 
      {
        return 5;
      } else if (angle >= 90.0 && 
                 angle < 150.0) 
      {
        return 4;
      } else if (angle >= 150.0 && 
                 angle < 210.0) 
      {
        return 3;
      } else if (angle >= 210.0 && 
                 angle < 270.0) 
      {
        return 2;
      } else if (angle >= 270.0 && 
                 angle < 330.0) 
      {
        return 1;
      }
      else
      {
        return 0;
      }
 
      
  #
  #
  # !!!attention:following code somehow causing crashes.... dont know why!!!!
  #
  #
  #- platform: template
  #  name: ${stepper_motor_id_upper}.plantposition
  #  id: ${stepper_motor_id}_plantposition
  #  update_interval: 1s
  #  lambda: |-
  #    float angle = id(${stepper_motor_id}_angle).state;
  #    
  #    if ((angle >= 1050.0 && 
  #        angle < 1080.0 )||
  #        (angle >= 0.0 && 
  #        angle < 30.0)) 
  #    {
  #      return 1;
  #    } else if (angle >= 30.0 && 
  #               angle < 90.0) 
  #    {
  #      return 2;
  #    } else if (angle >= 90.0 && 
  #               angle < 150.0) 
  #    {
  #      return 3;
  #    } else if (angle >= 150.0 && 
  #               angle < 210.0) 
  #    {
  #      return 4;
  #    } else if (angle >= 210.0 && 
  #               angle < 270.0) 
  #    {
  #      return 5;
  #    } else if (angle >= 270.0 && 
  #               angle < 330.0) 
  #    {
  #      return 6;
  #    } else if (angle >= 330.0 && 
  #               angle < 390.0) 
  #    {
  #      return 7;
  #    } else if (angle >= 390.0 && 
  #               angle < 450.0) 
  #    {
  #      return 8;
  #    } else if (angle >= 450.0 && 
  #               angle < 510.0) 
  #    {
  #      return 9;
  #    } else if (angle >= 510.0 && 
  #               angle < 570.0) 
  #    {
  #      return 1;
  #    } else if (angle >= 570.0 && 
  #               angle < 630.0) 
  #    {
  #      return 2;
  #    } else if (angle >= 630.0 && 
  #               angle < 690.0) 
  #    {
  #      return 3;
  #    } else if (angle >= 690.0 && 
  #               angle < 750.0) 
  #    {
  #      return 4;
  #    } else if (angle >= 750.0 && 
  #               angle < 810.0) 
  #    {
  #      return 5;
  #    } else if (angle >= 810.0 && 
  #               angle < 870.0) 
  #    {
  #      return 6;
  #    } else if (angle >= 870.0 && 
  #               angle < 930.0) 
  #    {
  #      return 7;
  #    } else if (angle >= 930.0 && 
  #               angle < 990.0) 
  #    {
  #      return 8;
  #    } else if (angle >= 990.0 && 
  #               angle < 1050.0) 
  #    {
  #      return 9;
  #    }
  #    else
  #    {
  #      return 0;
  #    }