Merge pull request #10 from muxa/dev

1.0.0-rc.6

Author: muxa

.gitignore

@@ -35,3 +35,4 @@ __pycache__
 toggle_example
 .esphome
 dimmable_light_example
+dual-switch-cover-example

README.md

@@ -61,6 +61,7 @@ binary_sensor:
   * **name** (**Required**, string): The name of the state. Must not repeat.
   * **on_enter** (*Optional*, [Automation](https://esphome.io/guides/automations.html#automation)): An automation to perform when entering this state. 
   * **on_leave** (*Optional*, [Automation](https://esphome.io/guides/automations.html#automation)): An automation to perform when leaving this state. It called before `on_enter` of the next state.
+  * **on_set** (*Optional*, [Automation](https://esphome.io/guides/automations.html#automation)): An automation to perform when setting this state using `set` action or via `initial_state`. Will not trigger if new state is the same as current state.
 
 * **inputs** (**Required**, list): The list of inputs that the state machine supports with allowed state transitions.
 
@@ -97,6 +98,29 @@ Configuration options:
 * **id** (*Optional*, [ID](https://esphome.io/guides/configuration-types.html#config-id)): The ID of the state machine.
 * **input** (**Required**, string): The input to provide in order to transition to the next state.
 
+## `state_machine.set` Action
+
+This action allows resetting the state machine current state, without going through transitions. This can be useful when initial state is not really know until some sensor data is available. Another example is when there's a "emergency escape" transition from every state to a particular state and adding a transition from every other state just makes the machine messy.
+
+> Note that only the target state `on_set` automation will be triggered, and all other state machine automations (`on_enter`, `on_leave` and `action` of the inputs and transitions) will be skipped.
+
+```yaml
+# in some trigger
+on_...:
+  # Basic:
+  - state_machine.set: OPEN
+
+  # Advanced (if you have multiple state machines in one YAML)
+  - state_machine.set:
+      id: sm1
+      state: OPEN
+```
+
+Configuration options:
+
+* **id** (*Optional*, [ID](https://esphome.io/guides/configuration-types.html#config-id)): The ID of the state machine.
+* **state** (**Required**, string): The state to set state machine to bypassing transitions.
+
 ## `state_machine.transition` Condition
 
 This condition lets you check what transition last occurred.
@@ -194,3 +218,13 @@ This example models a single button control for a dimmable light with the follow
 
 See [dimmable_light_example.yaml](dimmable_light_example.yaml).
 
+### Dual Switch Cover Control
+
+![Dual Switch Cover Control State Machine Diagram](images/state-machine-dual-switch-cover.svg)
+
+This example demonstrates using 2 switches to control a time-based cover:
+* Switch 1 ON: OPEN
+* Switch 2 ON: CLOSE
+* Both switches ON: enable Sun Tracker
+
+See [dual-switch-cover-example.yaml](dual-switch-cover-example.yaml).

components/state_machine/__init__.py

@@ -25,6 +25,10 @@
     "StateMachineComponent", cg.Component
 )
 
+StateMachineOnSetTrigger = state_machine_ns.class_(
+    "StateMachineOnSetTrigger", automation.Trigger.template()
+)
+
 StateMachineOnEnterTrigger = state_machine_ns.class_(
     "StateMachineOnEnterTrigger", automation.Trigger.template()
 )
@@ -41,6 +45,8 @@
     "StateMachineTransitionActionTrigger", automation.Trigger.template()
 )
 
+StateMachineSetAction = state_machine_ns.class_("StateMachineSetAction", automation.Action)
+
 StateMachineTransitionAction = state_machine_ns.class_("StateMachineTransitionAction", automation.Action)
 
 StateMachineTransitionCondition = state_machine_ns.class_("StateMachineTransitionCondition", automation.Condition)
@@ -51,6 +57,7 @@
 CONF_INPUTS_KEY = 'inputs'
 CONF_TRANSITIONS_KEY = 'transitions'
 
+CONF_STATE_ON_SET_KEY = 'on_set'
 CONF_STATE_ON_ENTER_KEY = 'on_enter'
 CONF_STATE_ON_LEAVE_KEY = 'on_leave'
 CONF_INPUT_TRANSITIONS_KEY = 'transitions'
@@ -61,6 +68,8 @@
 CONF_TRANSITION_INPUT_KEY = 'input'
 CONF_TRANSITION_TO_KEY = 'to'
 
+CONF_STATE_KEY = 'state'
+
 CONF_STATE_MACHINE_ID = 'state_machine_id'
 
 def validate_transition(value):
@@ -137,6 +146,11 @@ def unique_names(items):
                 cv.ensure_list(cv.maybe_simple_value(
                     {
                         cv.Required(CONF_NAME): cv.string_strict,
+                        cv.Optional(CONF_STATE_ON_SET_KEY): automation.validate_automation(
+                            {
+                                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateMachineOnSetTrigger),
+                            }
+                        ),
                         cv.Optional(CONF_STATE_ON_ENTER_KEY): automation.validate_automation(
                             {
                                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateMachineOnEnterTrigger),
@@ -221,7 +235,17 @@ async def to_code(config):
     if CONF_NAME in config:
         cg.add(var.set_name(config[CONF_NAME]))    
 
-    # setup on_leave automations first (to ensure they are executed before on_enter)
+    # setup on_set automations first
+    for state in config[CONF_STATES_KEY]:
+
+        if CONF_STATE_ON_LEAVE_KEY in state:
+            for action in state.get(CONF_STATE_ON_SET_KEY, []):
+                trigger = cg.new_Pvariable(
+                    action[CONF_TRIGGER_ID], var, state[CONF_NAME]
+                )
+                await automation.build_automation(trigger, [], action)
+
+    # then setup on_leave automations (to ensure they are executed before on_enter)
     for state in config[CONF_STATES_KEY]:
 
         if CONF_STATE_ON_LEAVE_KEY in state:
@@ -270,6 +294,22 @@ async def to_code(config):
 
     cg.add(var.dump_config())
 
+@automation.register_action(
+    "state_machine.set",
+    StateMachineSetAction,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(StateMachineComponent),
+            cv.Required(CONF_STATE_KEY): cv.string_strict,
+        },
+        key=CONF_STATE_KEY
+    ),
+)
+def state_machine_set_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg, config[CONF_STATE_KEY])
+    yield cg.register_parented(var, config[CONF_ID])
+    yield var
+
 @automation.register_action(
     "state_machine.transition",
     StateMachineTransitionAction,

components/state_machine/automation.h

@@ -9,6 +9,23 @@ namespace esphome
   namespace state_machine
   {
 
+    class StateMachineOnSetTrigger : public Trigger<>
+    {
+    public:
+      StateMachineOnSetTrigger(StateMachineComponent *state_machine, std::string state)
+      {
+        state_machine->add_on_set_callback(
+            [this, state](std::string new_state)
+            {
+              if (new_state == state)
+              {
+                this->stop_action(); // stop any previous running actions
+                this->trigger();
+              }
+            });
+      }
+    };
+
     class StateMachineOnEnterTrigger : public Trigger<>
     {
     public:
@@ -77,6 +94,21 @@ namespace esphome
       }
     };
 
+    template <typename... Ts>
+    class StateMachineSetAction : public Action<Ts...>, public Parented<StateMachineComponent>
+    {
+    public:
+      StateMachineSetAction(std::string state)
+      {
+        this->state_ = state;
+      }
+
+      void play(Ts... x) override { this->parent_->set(this->state_); }
+
+    protected:
+      std::string state_;
+    };
+
     template <typename... Ts>
     class StateMachineTransitionAction : public Action<Ts...>, public Parented<StateMachineComponent>
     {

components/state_machine/state_machine.cpp

@@ -27,11 +27,18 @@ namespace esphome
       this->name_ = name;
     }
 
+    void StateMachineComponent::setup()
+    {
+      auto initial_state = this->current_state_;
+      this->current_state_ = {};
+      this->set(initial_state);
+    }
+
     void StateMachineComponent::dump_config()
     {
       ESP_LOGCONFIG(TAG, "State Machine '%s'", this->name_.c_str());
 
-      ESP_LOGCONFIG(TAG, "Initial State: %s", this->current_state_.c_str());
+      ESP_LOGCONFIG(TAG, "Current State: %s", this->current_state_.c_str());
 
       ESP_LOGCONFIG(TAG, "States: %d", this->states_.size());
       for (auto &state : this->states_)
@@ -69,6 +76,21 @@ namespace esphome
       return {};
     }
 
+    void StateMachineComponent::set(std::string state)
+    {
+      if (std::find(this->states_.begin(), this->states_.end(), state) == this->states_.end())
+      {
+        ESP_LOGE(TAG, "Invalid state: %s", state.c_str());
+      }
+
+      if (state != this->current_state_)
+      {
+        ESP_LOGD(TAG, "State set to %s", state.c_str());
+        this->current_state_ = state;
+        this->set_callback_.call(state);
+      }
+    }
+
     optional<StateTransition> StateMachineComponent::transition(std::string input)
     {
       optional<StateTransition> transition = this->get_transition(input);

components/state_machine/state_machine.h

@@ -26,13 +26,16 @@ namespace esphome
       const std::string &get_name() const;
       void set_name(const std::string &name);
 
+      void setup() override;
       void dump_config() override;
 
       std::string current_state() { return this->current_state_; }
       optional<StateTransition> last_transition() { return this->last_transition_; }
 
+      void set(std::string state);
       optional<StateTransition> transition(std::string input);
 
+      void add_on_set_callback(std::function<void(std::string)> &&callback) { this->set_callback_.add(std::move(callback)); }
       void add_on_transition_callback(std::function<void(StateTransition)> &&callback) { this->transition_callback_.add(std::move(callback)); }
 
     protected:
@@ -46,6 +49,7 @@ namespace esphome
 
       optional<StateTransition> get_transition(std::string input);
 
+      CallbackManager<void(std::string)> set_callback_{};
       CallbackManager<void(StateTransition)> transition_callback_{};
     };
 

dimmable_light_example.yaml

@@ -39,8 +39,28 @@ state_machine:
                   call.perform();
       - name: HOLD
         transitions:
-          - ON -> EDITING
-          - EDITING -> ON
+          - from: "ON"
+            to: EDITING
+            action: # single flash to indicate beginning of editing
+              - light.turn_on:
+                  id: light1
+                  effect: Strobe
+              - delay: 0.2s
+              - light.turn_off: light1
+              - light.turn_on:
+                  id: light1
+                  transition_length: 100ms
+          - from: EDITING
+            to: "ON"
+            action: # tripple flash to indicate end of editing
+              - light.turn_on:
+                  id: light1
+                  effect: Strobe
+              - delay: 0.6s
+              - light.turn_off: light1
+              - light.turn_on:
+                  id: light1
+                  transition_length: 100ms
     diagram: true
 
 binary_sensor:
@@ -65,8 +85,16 @@ light:
   - platform: monochromatic
     name: "Light"
     id: light1
-    default_transition_length: 300ms
+    default_transition_length: 200ms
     output: led1
+    effects:
+        - strobe:
+            name: Strobe
+            colors:
+              - state: true
+                duration: 100ms
+              - state: false
+                duration: 100ms
 
 output:
   - platform: esp8266_pwm