lipomon.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2018-2019 Peter A. Bigot */
 
#ifndef NRFCXX_MISC_LIPOMON_HPP
#define NRFCXX_MISC_LIPOMON_HPP
#pragma once
 
#include <nrfcxx/periph.hpp>
#include <nrfcxx/lpm.hpp>
#include <nrfcxx/sensor/adc.hpp>
 
namespace nrfcxx {
namespace misc {
 
class lipo_monitor : public lpm::lpsm_capable
{
  using super = lpm::lpsm_capable;
 
public:
 
  enum PowerSource_e : uint8_t
  {
    PS_Unknown = 0,
    PS_OnBattery = 1,
    PS_Charging = 2,
    PS_Charged = 3,
  };
 
private:
  using flags_type = uint8_t;
 
  enum flags_enum : flags_type
  {
    FL_PWRSRCCAP_Pos = 0U,
    FL_PWRSRCCAP_Msk = 0x03 << FL_PWRSRCCAP_Pos,
 
    FL_PWRSRCPRC_Pos = 2U,
    FL_PWRSRCPRC_Msk = 0x03 << FL_PWRSRCPRC_Pos,
 
    FL_CALIBRATED = 0x10,
 
    FL_SAMPLING = 0x20,
 
    FL_SAMPLE_CORRUPTED = 0x40,
  };
 
  /* Power source changes affecting #PF_LIPO, #PF_MAINS, #PF_CHARGING,
   * #PF_CHARGED are decoupled from the battery sampling state.
   *
   * State transitions:
   *
   * * ENTRY_START enables change detection on VCHG_DETECT and
   *   CHGn_STATE, captures their initial state, and sets PF_STARTED.
   *   It falls through to ENTRY_CALIBRATE.
   *
   * * ENTRY_CALIBRATE queues an ADC calibration and falls into
   *   EXIT_CALIBRATE.
   *
   * * EXIT_CALIBRATE loops until calibration resolved, then records
   *   state of calibration and falls into ENTRY_VBATT.
   *
   * * ENTRY_VBATT if not calibrated jumps to ENTRY_CALIBRATE.
   *   Otherwise it invokes sample_setup() and transitions to VBATT
   *   (after a setup delay if necessary).
   *
   * * VBATT queues an ADC collection and transitions to EXIT_VBATT.
   *
   * * EXIT_VBATT is blocked until the ADC completes, then it invokes
   *   sample_teardown() and processes the sample, emitting
   *   #PF_OBSERVATION if the collection was valid.  It then
   *   transitions to IDLE.
   */
  static constexpr auto MS_ENTRY_CALIBRATE = lpm::state_machine::MS_ENTRY_SAMPLE + 1;
  static constexpr auto MS_EXIT_CALIBRATE = lpm::state_machine::MS_EXIT_SAMPLE + 1;
  static constexpr auto MS_ENTRY_VBATT = lpm::state_machine::MS_ENTRY_SAMPLE;
  static constexpr auto MS_VBATT = lpm::state_machine::MS_SAMPLE;
  static constexpr auto MS_EXIT_VBATT = lpm::state_machine::MS_EXIT_SAMPLE;
 
public:
  static constexpr auto PF_STARTED = lpm::state_machine::PF_STARTED;
 
  static constexpr auto PF_LIPO = lpm::state_machine::PF_APP_BASE;
 
  static constexpr auto PF_MAINS = lpm::state_machine::PF_APP_BASE << 1;
 
  static constexpr auto PF_CHARGING = lpm::state_machine::PF_APP_BASE << 2;
 
  static constexpr auto PF_CHARGED = lpm::state_machine::PF_APP_BASE << 3;
 
  static constexpr auto PF_CALIBRATED = lpm::state_machine::PF_APP_BASE << 5;
 
  lipo_monitor (notifier_type notify,
                const gpio::gpio_pin& vchg_detect,
                const gpio::gpio_pin& chgn_state,
                sensor::adc::voltage_divider& battmeas);
 
  bool vchg_detected_live ()
  {
    return vchg_detect_.read();
  }
 
  bool charging_live ()
  {
    return vchg_detect_.read() && !chgn_state_.read();
  }
 
  int calibrate ();
 
  int batt_mV () const
  {
    return batt_mV_;
  }
 
  int power_source () const;
 
private:
  using mutex_type = periph::GPIOTE::sense_listener::mutex_type;
  using adc_mutex_type = periph::ADCClient::mutex_type;
 
  void callback_bi_ (const periph::GPIOTE::sense_status_type* sp);
 
  int lpsm_process_ (int& delay,
                     process_flags_type& pf) override;
 
  periph::GPIOTE::sense_listener listener_;
 
  gpio::gpio_pin vchg_detect_;
  gpio::gpio_pin chgn_state_;
  sensor::adc::voltage_divider& battmeas_;
  int16_t batt_mV_ = 0;
 
  // Protected by mutex_type
  flags_type volatile flags_bi_ = 0;
 
  // These three protected by adc_mutex_type, if necessary.
  bool volatile adc_pending_ = false;
  int8_t volatile adc_calibrating_ = 0;
  int8_t volatile adc_sampling_ = 0;
};
 
} // ns misc
} // namespace
 
#endif /* NRFCXX_MISC_LIPOMON_HPP */