contact.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2017-2019 Peter A. Bigot */
 
#ifndef NRFCXX_SENSOR_CONTACT_HPP
#define NRFCXX_SENSOR_CONTACT_HPP
#pragma once
 
#include <type_traits>
 
#include <nrfcxx/clock.hpp>
#include <nrfcxx/gpio.hpp>
#include <nrfcxx/periph.hpp>
 
namespace nrfcxx {
namespace sensor {
 
namespace contact_internal {
 
static constexpr auto utt_per_ts = 256U;
 
template <typename INTEGRAL>
constexpr inline
INTEGRAL
ts_from_utt (INTEGRAL dur_utt)
{
  return dur_utt / utt_per_ts;
}
 
template <typename INTEGRAL>
constexpr inline
INTEGRAL
utt_from_ts (INTEGRAL dur_ts)
{
  return dur_ts * utt_per_ts;
}
 
} // ns contact_internals
 
class contact
{
public:
  static constexpr unsigned int HISTORY_LENGTH = 8;
 
  static constexpr unsigned int TIMESTAMP_Hz = contact_internal::ts_from_utt(clock::uptime::Frequency_Hz);
 
  template <typename INTEGRAL>
  static constexpr INTEGRAL ts_from_ms (INTEGRAL dur_ms)
  {
    return contact_internal::ts_from_utt(clock::uptime::from_ms(dur_ms));
  }
 
  template <typename INTEGRAL>
  static constexpr INTEGRAL utt_from_ts (INTEGRAL dur_ts)
  {
    return contact_internal::utt_from_ts(dur_ts);
  }
 
  using timestamp_type = uint64_t;
 
  using timediff_type = std::make_signed<uint64_t>::type;
 
  using reduced_timestamp_type = uint16_t;
 
  using duration_type = std::chrono::duration<timediff_type, std::ratio<1, TIMESTAMP_Hz>>;
 
  template <typename DurT = duration_type>
  constexpr static DurT to_duration (timediff_type dts)
  {
    return std::chrono::duration_cast<DurT>(duration_type{dts});
  }
 
  using mutex_type = periph::GPIOTE::mutex_type;
 
  using ordinal_type = uint16_t;
 
  struct state_type
  {
    using notify_fn = std::function<void(ordinal_type eo,
                                         timestamp_type ts)>;
 
    reduced_timestamp_type event_ts[HISTORY_LENGTH];
 
    ordinal_type ordinal;
 
    bool live_state;
 
    reduced_timestamp_type time_of_change (ordinal_type eo) const;
 
    reduced_timestamp_type time_of_change () const;
 
    timestamp_type captured_ts () const
    {
      return captured_ts_;
    }
 
    timestamp_type ordinal_ts () const;
 
    bool state_from_ordinal () const
    {
      return contact::state_from_ordinal(ordinal);
    }
 
    timestamp_type process_changes (const state_type& prev,
                                    notify_fn notify = nullptr,
                                    bool collapse = true) const;
 
  private:
    // contact sets captured_ts_
    friend class contact;
 
    timestamp_type captured_ts_;
  };
 
  uint8_t const psel;
 
  using change_callback_bi = std::function<void(ordinal_type ordinal)>;
 
  contact (uint8_t psel,
           change_callback_bi callback,
           uint32_t pin_cnf = gpio::PIN_CNF_RDONLY);
 
  void record_change_bi (bool double_tap = false);
 
  periph::GPIOTE::sense_listener sense_listener ()
  {
    return {[this](auto sp)
        {
          gpiote_sense_bi_(sp);
        }};
  }
 
  periph::GPIOTE::event_listener event_listener ()
  {
    return {[this](periph::GPIOTE& instance)
        {
          gpiote_event_bi_(instance);
        }};
  }
 
  static timestamp_type now ()
  {
    return clock::uptime::now() >> 8;
  }
 
  static reduced_timestamp_type timestamp ()
  {
    return clock::uptime::now24() >> 8;
  }
 
  bool live_state () const
  {
    return (1U << psel) & nrf5::GPIO->IN;
  }
 
  static bool state_from_ordinal (ordinal_type eo)
  {
    return (1 & eo);
  }
 
  state_type snapshot () const;
 
  timestamp_type epoch_ts () const;
 
protected:
  bool recorded_state_bi_ () const
  {
    return state_from_ordinal(state_bi_.ordinal);
  }
 
  void gpiote_sense_bi_ (const periph::GPIOTE::sense_status_type* sp);
 
  void gpiote_event_bi_ (periph::GPIOTE& instance)
  {
    bool double_tap = (live_state() == recorded_state_bi_());
    record_change_bi(double_tap);
  }
 
  change_callback_bi callback_;
 
  state_type volatile state_bi_;
};
 
} // ns sensor
} // ns nrfcxx
 
#endif /* NRFCXX_SENSOR_CONTACT_HPP */