hmi_contact.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cmath>        // for fmod
#include <map>          // for map<>
#include <memory>       // for shared_ptr<>
#include <string>       // for string
#include <type_traits>  // for enable_if<>
#include <utility>      // for make_pair<>
 
#include <boost/algorithm/string.hpp>  // for split, is_any_of
 
#include <cloe/core.hpp>     // for Confable, Json, Schema, Duration
#include <cloe/trigger.hpp>  // for Trigger, Action, ActionFactory
 
namespace cloe {
namespace utility {
 
template <typename D = Duration>
class Contact {
 public:
  explicit Contact(bool active) : active_(active) {}
  virtual ~Contact() = default;
 
  void update(D time, bool down) {
    // Skip if we are not releasing and we are also not pushing down.
    // This reduces the nominal case (false | false) to a single if instruction.
    if (active_ | down) {
      if (down) {
        contact_down(time);
      } else {
        contact_up(time);
      }
    }
  }
 
  bool has_contact() const { return active_; }
 
 protected:
  virtual void contact_down(D time) = 0;
 
  virtual void contact_up(D time) = 0;
 
  // Dynamic state
  bool active_{false};
};
 
template <typename D = Duration>
class ContactMap : public Confable {
  struct Button {
    std::shared_ptr<Contact<D>> contact;
    bool state;
  };
 
  std::map<std::string, Button> buttons_;
  schema::Struct schema_;
 
 public:
  void add(const std::string& key, std::shared_ptr<Contact<D>> c) {
    if (buttons_.count(key)) {
      throw std::logic_error("HMI contact '" + key + "' already exists.");
    }
    buttons_.emplace(std::make_pair(key, Button{c, c->has_contact()}));
    schema_.set_property(key, Schema(&(buttons_[key].state), "push " + key + " HMI contact"));
  }
 
  void add_new(const std::string& key, Contact<D>* c) { add(key, std::shared_ptr<Contact<D>>{c}); }
 
  void update(D time) {
    for (auto& elem : buttons_) {
      auto& b = elem.second;
      b.contact->update(time, b.state);
    }
  }
 
  Schema schema() { return schema_; }
 
  void to_json(Json& j) const override {
    for (auto& elem : buttons_) {
      j[elem.first] = elem.second.state;
    }
  }
 
  void from_conf(const Conf& c) override {
    for (auto& elem : buttons_) {
      c.try_from(elem.first, elem.second.state);
    }
  }
 
  CONFABLE_FRIENDS(ContactMap<D>)
};
 
template <typename D = Duration>
class UseContact : public Action {
 public:
  UseContact(const std::string& name, ContactMap<D>* m, const Conf& data)
      : Action(name), hmi_(m), data_(data) {}
  ActionPtr clone() const override { return std::make_unique<UseContact<D>>(name(), hmi_, data_); }
  CallbackResult operator()(const Sync&, TriggerRegistrar&) override { from_json(*data_, *hmi_); return CallbackResult::Ok; }
 
 protected:
  void to_json(Json& j) const override { j = *data_; }
 
 private:
  ContactMap<D>* hmi_;
  Conf data_;
};
 
template <typename D = Duration>
class ContactFactory : public ActionFactory {
 public:
  using ActionType = UseContact<D>;
  ContactFactory(ContactMap<D>* m, const std::string& name = "hmi")
      : ActionFactory(name, "connect and disconnect button contacts"), contacts_(m) {}
 
  TriggerSchema schema() const override {
    return TriggerSchema{
        this->name(),
        this->description(),
        InlineSchema("comma-separated list of buttons to press", "[!]<button>[,...]", true),
        contacts_->schema(),
    };
  }
 
  ActionPtr make(const Conf& c) const override {
    return std::make_unique<UseContact<D>>(name(), contacts_, c);
  }
 
  ActionPtr make(const std::string& s) const override {
    // 1. Split string by comma and ensure there is a valid key in each.
    //    (Note: it is infuriating that this is no easy way to do this in C++.)
    std::vector<std::string> fields;
    boost::split(fields, s, boost::is_any_of(","));
 
    // 2. Fill JSON with fields set to correct values.
    Json j;
    for (const auto& f : fields) {
      if (f.size() == 0) {
        throw Error("empty entry in comma-separated list");
      }
      bool value = (f[0] == '!' ? false : true);
      std::string key = (value ? f : f.substr(1));
      j[key] = value;
    }
 
    return make(Conf{j});
  }
 
 private:
  ContactMap<D>* contacts_;
};
 
template <typename D = Duration>
class Switch : public Contact<D> {
 public:
  Switch(std::function<void()> set_fn, std::function<void()> unset_fn, bool active)
      : Contact<D>(active), set_func_(set_fn), unset_func_(unset_fn) {}
  virtual ~Switch() = default;
 
 protected:
  void contact_down(D) override {
    // If we are already active, then ignore
    if (!this->active_) {
      this->active_ = true;
      set_func_();
    }
  }
 
  void contact_up(D) override {
    assert(this->active_);
    this->active_ = false;
    unset_func_();
  }
 
 private:
  std::function<void()> set_func_;
  std::function<void()> unset_func_;
};
 
template <typename D = Duration>
class PushButton : public Contact<D> {
 public:
  explicit PushButton(std::function<void()> click_fn) : Contact<D>(false), single_func_(click_fn) {}
  PushButton(std::function<void()> click_fn, std::function<void()> repeat_fn)
      : Contact<D>(false), single_func_(click_fn), repeat_func_(repeat_fn) {}
  virtual ~PushButton() = default;
 
  void set_delay(D delay) { delay_ = delay; }
 
  void set_interval(D interval) { interval_ = interval; }
 
 protected:
  void contact_down(D time) override {
    if (!this->active_) {
      this->active_ = true;
      last_event_ = time;
      return;
    } else if (!repeat_func_) {
      // If repeat_func_ is not set, than we don't care about the time,
      // and we will never trigger while the button is depressed.
      return;
    }
 
    if (repeated_) {
      // We've already activated the button at least once.
      if (time - last_event_ > interval_) {
        repeat_func_();
        last_event_ = time;
      }
    } else {
      // We have not activated the button yet.
      if (time - last_event_ > delay_) {
        repeat_func_();
        last_event_ = time;
        repeated_ = true;
      }
    }
  }
 
  void contact_up(D) override {
    assert(this->active_);
    if (!repeated_) {
      single_func_();
    }
    reset();
  }
 
  void reset() {
    this->active_ = false;
    repeated_ = false;
    last_event_ = D::zero();
  }
 
 private:
  std::function<void()> single_func_;
  std::function<void()> repeat_func_;
  D delay_{std::chrono::milliseconds(500)};
  D interval_{std::chrono::milliseconds(250)};
 
  // Dynamic state
  D last_event_{D::zero()};
  bool repeated_{false};
};
 
namespace contact {
 
template <typename N>
typename std::enable_if<std::is_integral<N>::value, N>::type round_step(N target, N increment) {
  auto rem = target % increment;
  if (rem != 0) {
    if (increment < 0) {
      return target - rem;
    } else {
      return target + (increment - rem);
    }
  } else {
    return target + increment;
  }
}
 
template <typename N>
typename std::enable_if<std::is_floating_point<N>::value, N>::type round_step(N target,
                                                                              N increment) {
  auto rem = fmod(target, increment);
  if (rem != 0.0) {
    if (increment < 0) {
      return target - rem;
    } else {
      return target + (increment - rem);
    }
  } else {
    return target + increment;
  }
}
 
template <typename D = Duration>
Switch<D>* make_switch(bool* ptr) {
  assert(ptr != nullptr);
  return new Switch<D>([ptr]() { *ptr = true; }, [ptr]() { *ptr = false; }, *ptr);
}
 
template <typename D = Duration>
PushButton<D> make_toggle(bool* ptr) {
  assert(ptr != nullptr);
  return PushButton<D>([ptr]() { *ptr = !(*ptr); });
}
 
template <typename D = Duration, typename N>
PushButton<D> make_step(N* ptr, N single) {
  assert(ptr != nullptr);
  return PushButton<D>([ptr, single]() { *ptr += single; });
}
 
template <typename D = Duration, typename N>
PushButton<D> make_step(N* ptr, N single, N multiple) {
  assert(ptr != nullptr);
  return PushButton<D>([ptr, single]() { *ptr += single; },
                       [ptr, multiple]() { *ptr += multiple; });
}
 
template <typename D = Duration, typename N>
PushButton<D> make_round_step(N* ptr, N single) {
  assert(ptr != nullptr);
  assert(single != 0);
  return PushButton<D>([ptr, single]() { *ptr = round_step(*ptr, single); });
}
 
template <typename D = Duration, typename N>
PushButton<D> make_round_step(N* ptr, N single, N multiple) {
  assert(ptr != nullptr);
  assert(single != 0);
  assert(multiple != 0);
  return PushButton<D>([ptr, single]() { *ptr = round_step(*ptr, single); },
                       [ptr, multiple]() { *ptr = round_step(*ptr, multiple); });
}
 
template <typename D = Duration, typename N>
PushButton<D> make_round_step_nonnegative(N* ptr, N single) {
  assert(ptr != nullptr);
  assert(single != 0);
  return PushButton<D>([ptr, single]() {
    *ptr = round_step(*ptr, single);
    if (*ptr < 0) {
      *ptr = 0;
    }
  });
}
 
template <typename D = Duration, typename N>
PushButton<D> make_round_step_nonnegative(N* ptr, N single, N multiple) {
  assert(ptr != nullptr);
  assert(single != 0);
  assert(multiple != 0);
  return PushButton<D>(
      [ptr, single]() {
        *ptr = round_step(*ptr, single);
        if (*ptr < 0) {
          *ptr = 0;
        }
      },
      [ptr, multiple]() {
        *ptr = round_step(*ptr, multiple);
        if (*ptr < 0) {
          *ptr = 0;
        }
      });
}
 
}  // namespace contact
 
}  // namespace utility
}  // namespace cloe