robot_0.yaml

#------------------------------
#-- robot_0.yaml
#-- Code pour piloter un petit robot NodeMCU à 20 balles au moyen d'un brocker MQTT
#-- Les commandes sont expressément très simplistes
#-- location: Hôtel du Cervin à St-Luc ;-)
#-- zf230122.1510

#--
# sources: 
# ...

substitutions:
  devicename: robot_1


esphome:
  name: $devicename
  on_boot:
   - switch.turn_on: ${devicename}_motor_direction_forward
   - switch.turn_on: ${devicename}_stop
   - switch.turn_on: ${devicename}_led
   - delay: 0.5s
   - switch.turn_off: ${devicename}_led


esp8266:
  board: nodemcuv2


# Configuration WIFI
wifi:
  ssid: !secret wifi_ssid_cours_iot
  password: !secret wifi_pass_cours_iot

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "${devicename} Fallback"
    password: !secret ap_wifi_password


captive_portal:


# Enable logging
logger:
  level: DEBUG
  logs:
    sensor: INFO
    ultrasonic.sensor: INFO
  

# Enable Home Assistant API
# api:
#   password: !secret api_password


ota:
  password: !secret ota_password


# WEB Server
web_server:
  port: 80


# Définitions du MQTT server
mqtt:
  broker:  192.168.20.107
  port:  1883
  username:  toto
  password:  tutu
  birth_message:
  will_message:

  on_message:
  # Commandes de déplacements du robot
    - topic: ${devicename}/switch/${devicename}_motor_start/set
      payload: 'ON'
      then:
        - logger.log: Receive START command !
        - switch.turn_on:
            id: ${devicename}_start

    - topic: ${devicename}/switch/${devicename}_motor_stop/set
      payload: 'ON'
      then:
        - logger.log: Receive STOP command !
        - switch.turn_on:
            id: ${devicename}_stop

    - topic: ${devicename}/switch/${devicename}_motor_go/set
      payload: 'ON'
      then:
        - logger.log: Receive GO command !
        - switch.turn_on:
            id: ${devicename}_go

    - topic: ${devicename}/switch/${devicename}_motor_direction_forward/set
      payload: 'ON'
      then:
        - logger.log: Receive FORWARD command !
        - switch.turn_on:
            id: ${devicename}_motor_direction_forward

    - topic: ${devicename}/switch/${devicename}_motor_direction_backward/set
      payload: 'ON'
      then:
        - logger.log: Receive BACKWARD command !
        - switch.turn_on:
            id: ${devicename}_motor_direction_backward

    - topic: ${devicename}/switch/${devicename}_motor_direction_left/set
      payload: 'ON'
      then:
        - logger.log: Receive LEFT command !
        - switch.turn_on:
            id: ${devicename}_motor_direction_left

    - topic: ${devicename}/switch/${devicename}_motor_direction_right/set
      payload: 'ON'
      then:
        - logger.log: Receive RIGHT command !
        - switch.turn_on:
            id: ${devicename}_motor_direction_right

  on_json_message:
    # valeurs de réglages pour le robot
    - topic: ${devicename}/number/${devicename}_motor_speed/set
      then:
        - logger.log: Receive Motor Speed value !
        - number.set:
            id: ${devicename}_motor_speed
            value: !lambda |-
                        return x["value"];

    - topic: ${devicename}/number/${devicename}_motor_preburn/set
      then:
        - logger.log: Receive Motor Preburn value !
        - number.set:
            id: ${devicename}_motor_preburn
            value: !lambda |-
                        return x["value"];

    - topic: ${devicename}/number/${devicename}_motor_preburn_time/set
      then:
        - logger.log: Receive Motor Preburn Time value !
        - number.set:
            id: ${devicename}_motor_preburn_time
            value: !lambda |-
                        return x["value"];

    - topic: ${devicename}/number/${devicename}_motor_differentiel/set
      then:
        - logger.log: Receive Motor Differentiel value !
        - number.set:
            id: ${devicename}_motor_differentiel
            value: !lambda |-
                        return x["value"];

    - topic: ${devicename}/number/${devicename}_motor_time/set
      then:
        - logger.log: Receive Motor Time value !
        - number.set:
            id: ${devicename}_motor_time
            value: !lambda |-
                        return x["value"];


# Définition des Switch's
switch:
  - platform: gpio
    name: "${devicename} LED"
    inverted: True
    id: ${devicename}_led
    pin: D0

  - platform: restart
    name: "${devicename} Restart"

  - platform: gpio
    name: "${devicename} Motor Direction A "
    # inverted: True
    id: ${devicename}_motor_direction_a
    pin: D3

  - platform: gpio
    name: "${devicename} Motor Direction B"
    # inverted: True
    id: ${devicename}_motor_direction_b
    pin: D4

  - platform: template
    name: "${devicename} Motor GO"
    id: ${devicename}_go
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      - switch.turn_on:
          id: ${devicename}_start

  - platform: template
    name: "${devicename} Motor START"
    id: ${devicename}_start
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      # Préchauffage des moteurs pour combattre le frottement mu zéro
      - light.turn_on:
          id: ${devicename}_motor_speed_a
          brightness:  !lambda |-
            // output value must be in range 0 - 1.0
            return id(${devicename}_motor_preburn).state / 100;
      - light.turn_on:
          id: ${devicename}_motor_speed_b
          brightness:  !lambda |-
            // output value must be in range 0 - 1.0
            return id(${devicename}_motor_preburn).state / 100;
      - delay: !lambda return id(${devicename}_motor_preburn_time).state * 1000;
# Allumage des moteurs selon la consigne avec le différentiel gauche/droite
      - light.turn_on:
          id: ${devicename}_motor_speed_a
          brightness:  !lambda |-
            // output value must be in range 0 - 1.0
            return id(${devicename}_motor_speed).state / 100.0 * (0.5 + id(${devicename}_motor_differentiel).state);
      - light.turn_on:
          id: ${devicename}_motor_speed_b
          brightness:  !lambda |-
            // output value must be in range 0 - 1.0
            return id(${devicename}_motor_speed).state / 100.0 / (0.5 + id(${devicename}_motor_differentiel).state);
      - switch.turn_off: ${devicename}_stop

  - platform: template
    name: "${devicename} Motor STOP"
    id: ${devicename}_stop
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      - switch.turn_off:
          id: ${devicename}_start
      - light.turn_off:
          id: ${devicename}_motor_speed_a
      - light.turn_off:
          id: ${devicename}_motor_speed_b
      - switch.turn_off: ${devicename}_start
      - switch.turn_off: ${devicename}_go

  - platform: template
    name: "${devicename} Motor Direction FORWARD"
    id: ${devicename}_motor_direction_forward
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      - switch.turn_off: ${devicename}_motor_direction_a
      - switch.turn_off: ${devicename}_motor_direction_b
      - switch.turn_off: ${devicename}_motor_direction_backward
      - switch.turn_off: ${devicename}_motor_direction_right
      - switch.turn_off: ${devicename}_motor_direction_left

  - platform: template
    name: "${devicename} Motor Direction BACKWARD"
    id: ${devicename}_motor_direction_backward
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      - switch.turn_on: ${devicename}_motor_direction_a
      - switch.turn_on: ${devicename}_motor_direction_b
      - switch.turn_off: ${devicename}_motor_direction_forward
      - switch.turn_off: ${devicename}_motor_direction_right
      - switch.turn_off: ${devicename}_motor_direction_left

  - platform: template
    name: "${devicename} Motor Direction RIGHT"
    id: ${devicename}_motor_direction_right
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      - switch.turn_off: ${devicename}_motor_direction_a
      - switch.turn_on: ${devicename}_motor_direction_b
      - switch.turn_off: ${devicename}_motor_direction_left
      - switch.turn_off: ${devicename}_motor_direction_forward
      - switch.turn_off: ${devicename}_motor_direction_backward

  - platform: template
    name: "${devicename} Motor Direction LEFT"
    id: ${devicename}_motor_direction_left
    optimistic: true
    restore_mode: ALWAYS_OFF
    turn_on_action:
      - switch.turn_on: ${devicename}_motor_direction_a
      - switch.turn_off: ${devicename}_motor_direction_b
      - switch.turn_off: ${devicename}_motor_direction_right
      - switch.turn_off: ${devicename}_motor_direction_forward
      - switch.turn_off: ${devicename}_motor_direction_backward


# Définition des Output's
output:
  - platform: esp8266_pwm
    pin: D1
    frequency: 50 Hz
    id: ${devicename}_motor_pwm_a

  - platform: esp8266_pwm
    pin: D2
    frequency: 50 Hz
    id: ${devicename}_motor_pwm_b


# Définition des Light's
light:
  - platform: monochromatic
    output: ${devicename}_motor_pwm_a
    name: "${devicename} motor Speed A"
    id: ${devicename}_motor_speed_a
    internal: true

  - platform: monochromatic
    output: ${devicename}_motor_pwm_b
    name: "${devicename} motor Speed B"
    id: ${devicename}_motor_speed_b
    internal: true


# Définition des Sensors
sensor:
  - platform: wifi_signal
    name: "${devicename} Signal Wi-Fi"
    update_interval: 15s
    on_value:
      then:
        - switch.turn_on: ${devicename}_led

  - platform: uptime
    name: "${devicename} uptime"
    update_interval: 5s

  - platform: ultrasonic
    trigger_pin: D5
    echo_pin: D6
    name: "${devicename} Distance"
    id: ${devicename}_distance
    update_interval: 0.25s
    on_value:
      then:
        - if:
            condition:
              lambda: 'return (id(${devicename}_start).state == 1 and id(${devicename}_motor_direction_forward).state == 1 and id(${devicename}_distance).state < 0.25) ;'
            then:
              - switch.turn_off:
                  id: ${devicename}_start
              - switch.turn_on:
                  id: ${devicename}_stop
              - switch.turn_off:
                  id: ${devicename}_go


# Définition des Sensors text
text_sensor:
  - platform: version
    name: "${devicename} Version 1209"

  - platform: wifi_info
    ip_address:
      name: ${devicename} IP Address
      id: wifi_ip
    ssid:
      name: ${devicename} Connected SSID
      id: wifi_ssid


# Définition des inputs numbers
number:
  - platform: template
    name: "${devicename} Motor Speed"
    id: ${devicename}_motor_speed
    restore_value: true
    optimistic: true
    mode: box
    min_value: 60
    max_value: 100
    step: 1
    initial_value: 75
    unit_of_measurement: "%"

  - platform: template
    name: "${devicename} Motor Preburn"
    id: ${devicename}_motor_preburn
    restore_value: true
    optimistic: true
    mode: box
    min_value: 75
    max_value: 100
    step: 3
    initial_value: 100
    unit_of_measurement: "%"

  - platform: template
    name: "${devicename} Motor Preburn Time"
    id: ${devicename}_motor_preburn_time
    restore_value: true
    optimistic: true
    mode: box
    min_value: 0
    max_value: 1
    step: 0.01
    initial_value: 1
    unit_of_measurement: "S"

  - platform: template
    name: "${devicename} Motor Differentiel"
    id: ${devicename}_motor_differentiel
    restore_value: true
    optimistic: true
    mode: box
    min_value: 0.2
    max_value: 0.8
    step: 0.01
    initial_value: 0.50
    unit_of_measurement: ""

  - platform: template
    name: "${devicename} Motor Time"
    id: ${devicename}_motor_time
    restore_value: false
    optimistic: true
    mode: box
    min_value: 0
    max_value: 20
    # ATTENTION, ne pas modifier le 'step' car c'est le 'décrement' du chronomètre de la commande 'go'
    step: 0.2
    initial_value: 2
    unit_of_measurement: "S"


# Gestion des timers
interval:


# Timer pour calculer le temps passé à avancer !
  - interval: 0.2s
    then:
      - if:
          condition:
            lambda: 'return (id(${devicename}_motor_time).state > 0 and id(${devicename}_go).state == 1) ;'
          then:
            - number.decrement:
                id: ${devicename}_motor_time
                cycle: false
          else:
            - if:
                condition:
                  lambda: 'return id(${devicename}_go).state == 1;'
                then:
                  - switch.turn_on:
                      id: ${devicename}_stop