lpm.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2018-2019 Peter A. Bigot */
 
#ifndef NRFCXX_LPM_HPP
#define NRFCXX_LPM_HPP
#pragma once
 
#include <nrfcxx/clock.hpp>
 
namespace nrfcxx {
 
namespace lpm {
 
class state_machine
{
public:
  using state_type = unsigned int;
 
  using process_flags_type = unsigned int;
 
  using error_type = int;
 
  static constexpr state_type STATE_MASK = ((1U << 24) - 1);
 
  static constexpr state_type STATE_HAS_ERROR = (1U << 24);
 
  static constexpr state_type STATE_BLOCKING_ALARM = (1U << 25);
 
  static constexpr state_type STATE_FALLBACK_ALARM = (1U << 26);
 
  static constexpr state_type STATE_STOP_PENDING = (1U << 26);
 
  static constexpr state_type MS_OFF = 0x0000;
 
  static constexpr state_type MS_ENTRY_START = 0x0001;
 
  static constexpr state_type MS_LOST = 0x0003;
 
  static constexpr state_type MS_ENTRY_RESET = 0x0010;
 
  static constexpr state_type MS_EXIT_RESET = 0x0011;
 
  static constexpr state_type MS_ENTRY_ERRORED = 0x0012;
  static constexpr state_type MS_ERRORED = 0x0013;
  static constexpr state_type MS_ENTRY_FAILED = 0x0014;
  static constexpr state_type MS_FAILED = 0x0015;
  static constexpr state_type MS_ENTRY_STOPPED = 0x0016;
 
  static constexpr state_type MS_ENTRY_SETUP = 0x0020;
 
  static constexpr state_type MS_EXIT_SETUP = 0x0030;
 
  static constexpr state_type MS_IDLE = 0x0040;
 
  static constexpr state_type MS_ENTRY_SAMPLE = 0x0050;
 
  static constexpr state_type MS_SAMPLE = 0x0060;
 
  static constexpr state_type MS_EXIT_SAMPLE = 0x0070;
 
  static constexpr state_type MS_APP_BASE{0x100};
 
  static constexpr process_flags_type PF_OFF = 0x01;
 
  static constexpr process_flags_type PF_STARTED = 0x02;
 
  static constexpr process_flags_type PF_RESET = 0x04;
 
  static constexpr process_flags_type PF_FAILED = 0x08;
 
  static constexpr process_flags_type PF_STOPPED = 0x10;
 
  static constexpr process_flags_type PF_OBSERVATION = 0x20;
 
  static constexpr process_flags_type PF_APP_BASE = 0x100;
 
  /* You can't move or copy these. */
  state_machine (const state_machine&) = delete;
  state_machine& operator= (const state_machine&) = delete;
  state_machine (state_machine&&) = delete;
  state_machine& operator= (state_machine&&) = delete;
  state_machine (notifier_type notify) :
    notify_{notify},
    alarm_{alarm_callback_, this}
  { }
 
  void reset();
 
  state_type state () const
  {
    return state_ & STATE_MASK;
  }
 
  state_type full_state () const
  {
    return state_;
  }
 
  void set_state (state_type state,
                  bool post = false)
  {
    state_ = state;
    if (post) {
      post_event();
    }
  }
 
  bool has_error () const
  {
    return STATE_HAS_ERROR & state_;
  }
 
  void set_error ()
  {
    state_ |= STATE_HAS_ERROR;
  }
 
  void set_error (error_type error)
  {
    state_ |= STATE_HAS_ERROR;
    error_ = error;
  }
 
  void set_lost ();
 
  error_type error () const
  {
    return error_;
  }
 
  bool blocking_alarm_pending () const
  {
    return STATE_BLOCKING_ALARM & state_;
  }
 
  bool fallback_alarm_pending () const
  {
    return STATE_FALLBACK_ALARM & state_;
  }
 
  void post_event ()
  {
    notify_();
  }
 
  int deadline () const
  {
    return alarm_.deadline();
  }
 
  void set_delay (int delay_utt);
 
  void cancel_delay ();
 
protected:
  static bool alarm_callback_ (clock::alarm& alarm);
 
private:
  notifier_type notify_;
  clock::alarm alarm_;
  state_type state_ = 0;
  error_type error_ = 0;
};
 
class lpsm_capable
{
  int process_rc_ = 0;
protected:
  lpsm_capable (notifier_type notify) :
    machine_{notify}
  { }
 
  state_machine machine_;
 
  using state_type = state_machine::state_type;
  using process_flags_type = state_machine::process_flags_type;
 
  virtual int lpsm_process_ (int& delay,
                             process_flags_type& pf)
  {
    return -1;
  }
 
  virtual void lpsm_reset_ ()
  { }
 
public:
  virtual ~lpsm_capable () = default;
 
  virtual int lpsm_start ();
 
  virtual int lpsm_sample ();
 
  lpm::state_machine::process_flags_type lpsm_process ();
 
  int lpsm_stop ()
  {
    return -1;
  }
 
  int lpsm_reset ()
  {
    /* This is not functionally complete, but is stubbed to trace the
     * dependence between lpsm_capable and its subclasses for clearing
     * external state such as flags not maintained in the state
     * machine. */
    lpsm_reset_();
    machine_.reset();
    return 0;
  }
 
  int lpsm_process_rc () const
  {
    return process_rc_;
  }
 
  const lpm::state_machine& machine () const
  {
    return machine_;
  }
 
};
 
} // ns lpm
} // ns nrfcxx
 
#endif /* NRFCXX_LPM_HPP */