WC: Fix HAP input handling logic

 * Separate last HAP and external (buttons) movement states
 * Expire HAP movement state after 1 minute. This provides
   intuitive behavior within short time span so short-term interactive use
   is unaffected and allow automated changes to work properly.

#254

Author: rojer

src/shelly_hap_window_covering.cpp

@@ -180,9 +180,10 @@ Component::Type WindowCovering::type() const {
 }
 
 StatusOr<std::string> WindowCovering::GetInfo() const {
-  return mgos::SPrintf("c:%d mp:%.2f mt_ms:%d cp:%.2f tp:%.2f lemd:%d",
+  return mgos::SPrintf("c:%d mp:%.2f mt_ms:%d cp:%.2f tp:%.2f lemd:%d lhmd:%d",
                        cfg_->calibrated, cfg_->move_power, cfg_->move_time_ms,
-                       cur_pos_, tgt_pos_, (int) last_ext_move_dir_);
+                       cur_pos_, tgt_pos_, (int) last_ext_move_dir_,
+                       (int) last_hap_move_dir_);
 }
 
 StatusOr<std::string> WindowCovering::GetInfoJSON() const {
@@ -331,19 +332,35 @@ void WindowCovering::SetTgtPos(float new_tgt_pos, const char *src) {
   tgt_pos_char_->RaiseEvent();
 }
 
+// We want tile taps to cycle the open-stop-close-stop sequence.
+// Problem is, tile taps behave as "prefer close": Home will send
+// 0 ("fully close") if tile is tapped while in the intermediate position.
+// We try to detect this case and ignore the target setting, instead
+// we use the opposite of last action. This results in more natural and
+// intuitive behavior (originally requested in
+// https://github.com/mongoose-os-apps/shelly-homekit/issues/181).
+// However, this causes issues with automations (reported in
+// https://github.com/mongoose-os-apps/shelly-homekit/issues/254).
+// To address this, we "expire" last state after 1 minute. This provides
+// intuitive behavior within short time span so short-term interactive use
+// is unaffected and allow automated changes to work properly.
 void WindowCovering::HAPSetTgtPos(float value) {
-  LOG(LL_INFO, ("WC %d: HAPSetTgtPos %.2f cur %.2f tgt %.2f lemd %d", id(),
-                value, cur_pos_, tgt_pos_, (int) last_ext_move_dir_));
+  // If last action was a while ago, ignore it.
+  if (mgos_uptime_micros() - last_hap_set_tgt_pos_ > 60 * 1000000) {
+    last_hap_move_dir_ = Direction::kNone;
+  }
+  LOG(LL_INFO, ("WC %d: HAPSetTgtPos %.2f cur %.2f tgt %.2f lhmd %d", id(),
+                value, cur_pos_, tgt_pos_, (int) last_hap_move_dir_));
   // If the specified position is intermediate, just do what we are told.
   if ((value != kFullyClosed && value != kFullyOpen) ||
-      last_ext_move_dir_ == Direction::kNone) {
+      last_hap_move_dir_ == Direction::kNone) {
     SetTgtPos(value, "HAP");
     if (value == kFullyClosed) {
-      last_ext_move_dir_ = Direction::kClose;
+      last_hap_move_dir_ = Direction::kClose;
     } else if (value == kFullyOpen) {
-      last_ext_move_dir_ = Direction::kOpen;
+      last_hap_move_dir_ = Direction::kOpen;
     } else {
-      last_ext_move_dir_ = Direction::kNone;
+      last_hap_move_dir_ = Direction::kNone;
     }
   } else if ((value == kFullyClosed &&
               (cur_pos_ == kFullyClosed || tgt_pos_ == kFullyClosed)) ||
@@ -352,8 +369,9 @@ void WindowCovering::HAPSetTgtPos(float value) {
     // Nothing to do.
   } else {
     // This is most likely a tap on the tile.
-    HandleInputSingle("HAPalt");
+    HandleInputSingle("HAPalt", &last_hap_move_dir_);
   }
+  last_hap_set_tgt_pos_ = mgos_uptime_micros();
   // Run state machine immediately to improve reaction time,
   RunOnce();
 }
@@ -622,6 +640,7 @@ void WindowCovering::HandleInputEvent01(Direction dir, Input::Event ev,
   if (state) {
     if (moving_dir_ == Direction::kNone || moving_dir_ != dir) {
       float pos = (dir == Direction::kOpen ? kFullyOpen : kFullyClosed);
+      last_ext_move_dir_ = dir;
       SetTgtPos(pos, "ext");
     } else {
       stop = true;
@@ -634,6 +653,7 @@ void WindowCovering::HandleInputEvent01(Direction dir, Input::Event ev,
     RunOnce();
     SetTgtPos(cur_pos_, "ext");
   }
+  last_hap_move_dir_ = Direction::kNone;
   // Run the state machine immediately for quicker response.
   RunOnce();
 }
@@ -645,7 +665,8 @@ void WindowCovering::HandleInputEvent2(Input::Event ev, bool state) {
   }
   if (ev != Input::Event::kChange) return;
   if (!state) return;
-  HandleInputSingle("ext");
+  HandleInputSingle("ext", &last_ext_move_dir_);
+  last_hap_move_dir_ = Direction::kNone;
   // Run the state machine immediately for quicker response.
   RunOnce();
 }
@@ -665,15 +686,16 @@ void WindowCovering::HandleInputEventNotCalibrated() {
   out_close_->SetState(want_close, "ext");
 }
 
-void WindowCovering::HandleInputSingle(const char *src) {
+void WindowCovering::HandleInputSingle(const char *src,
+                                       Direction *last_move_dir) {
   switch (moving_dir_) {
     case Direction::kNone: {
-      if (cur_pos_ == kFullyClosed || last_ext_move_dir_ != Direction::kOpen) {
+      if (cur_pos_ == kFullyClosed || *last_move_dir != Direction::kOpen) {
         SetTgtPos(kFullyOpen, src);
-        last_ext_move_dir_ = Direction::kOpen;
+        *last_move_dir = Direction::kOpen;
       } else {
         SetTgtPos(kFullyClosed, src);
-        last_ext_move_dir_ = Direction::kClose;
+        *last_move_dir = Direction::kClose;
       }
       break;
     }

src/shelly_hap_window_covering.hpp

@@ -109,7 +109,7 @@ class WindowCovering : public Component, public Service {
   void HandleInputEvent01(Direction dir, Input::Event ev, bool state);
   void HandleInputEvent2(Input::Event ev, bool state);
   void HandleInputEventNotCalibrated();
-  void HandleInputSingle(const char *src);
+  void HandleInputSingle(const char *src, Direction *last_move_dir);
 
   Input *in_open_, *in_close_;
   Output *out_open_, *out_close_;
@@ -137,8 +137,10 @@ class WindowCovering : public Component, public Service {
   float move_start_pos_ = 0;
   float move_ms_per_pct_ = 0;
   bool obstruction_detected_ = false;
+  int64_t last_hap_set_tgt_pos_ = 0;
   Direction moving_dir_ = Direction::kNone;
   Direction last_ext_move_dir_ = Direction::kNone;
+  Direction last_hap_move_dir_ = Direction::kNone;
 };
 
 }  // namespace hap