led.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2015-2019 Peter A. Bigot */
 
#ifndef NRFCXX_LED_HPP
#define NRFCXX_LED_HPP
#pragma once
 
#include <nrfcxx/clock.hpp>
#include <nrfcxx/gpio.hpp>
#include <nrfcxx/impl.hpp>
 
namespace nrfcxx {
 
namespace led {
 
class led_type
{
private:
  static led_type** const ledps_;
  static uint8_t const nleds_;
 
protected:
  led_type () = default;
 
public:
  virtual ~led_type ()
  {
    disable();
  }
 
  /* You can't copy, assign, move, or otherwise change the set of LEDs
   * that the system provides to you.  You can define additional LEDs
   * that aren't in the board-defined sequence. */
  led_type (const led_type&) = delete;
  led_type& operator= (const led_type&) = delete;
  led_type (const led_type&&) = delete;
  led_type& operator= (led_type&&) = delete;
 
  virtual bool exists (void) const
  {
    return false;
  }
 
  void enable (void)
  {
    off();
    enable_();
  }
 
  void disable (void)
  {
    disable_();
  }
 
  void set (int v)
  {
    if (0 < v) {
      on();
    } else if (0 == v) {
      off();
    } else {
      toggle();
    }
  }
 
  virtual void off (void)
  { }
 
  virtual void on (void)
  { }
 
  virtual void toggle (void)
  {
    if (is_on()) {
      off();
    } else {
      on();
    }
  }
 
  virtual bool is_on (void) const
  {
    return false;
  }
 
  static size_t count (void)
  {
    return nleds_;
  }
 
  static led_type& lookup (unsigned int i)
  {
    if (i < nleds_) {
      return *(ledps_[i]);
    }
    return no_led;
  }
 
  static led_type no_led;
 
protected:
  virtual void enable_ ()
  { }
 
  virtual void disable_ ()
  { }
};
 
inline led_type& lookup (unsigned int i)
{
  return led_type::lookup(i);
}
 
template <bool active_low = true>
class generic_led : public led_type
{
public:
  explicit generic_led (gpio::generic_pin& pin) :
    pin_{pin}
  { }
 
private:
  gpio::generic_pin& pin_;
 
  bool exists (void) const override
  {
    return true;
  }
 
  void enable_ (void) override
  {
    pin_.configure(gpio::PIN_CNF_WRONLY);
  }
 
  void disable_ (void) override
  {
    pin_.configure(gpio::PIN_CNF_PWRUP);
  }
 
  void off (void) override
  {
    if constexpr (active_low) {
      pin_.set();
    } else {
      pin_.clear();
    }
  }
 
  void on (void) override
  {
    if constexpr (active_low) {
      pin_.clear();
    } else {
      pin_.set();
    }
  }
 
  bool is_on (void) const override
  {
    return pin_.is_set() ^ active_low;
  }
};
 
class Pattern
{
  static constexpr uint8_t FLAG_LOOP = 0x01;
  static constexpr uint8_t FLAG_ACTIVE = 0x02;
 
public:
  /* Can't set an interval less than ~ 250 us.  (Really it's that you
   * can't set an interval of zero, but one less than 2 will livelock,
   * and really anything less than 500 us will probably be
   * indistinguishable.) */
  static constexpr unsigned int MIN_INTERVAL_utt = 8U;
 
  Pattern (led_type& led) :
    led{led},
    alarm_{alarm_callback, this}
  { }
 
  led_type& led;
 
  unsigned int pattern () const
  {
    return pattern_;
  }
 
  void set_notify_complete (notifier_type notify)
  {
    notify_complete_ = notify;
  }
 
  int reps () const
  {
    return (FLAG_LOOP & flags_) ? -1 : initial_reps_;
  }
 
  unsigned int interval_utt () const
  {
    return interval_;
  }
 
  int configure (unsigned int pattern,
                 unsigned int interval_utt,
                 int reps = -1);
 
  bool active () const
  {
    return FLAG_ACTIVE & flags_;
  }
 
  bool loops () const
  {
    return FLAG_LOOP & flags_;
  }
 
  unsigned int deadline () const
  {
    return alarm_.deadline();
  }
 
  int set_deadline (unsigned int deadline);
 
  int start (int delay_utt = -1);
 
  void cancel ();
 
private:
  static bool alarm_callback (clock::alarm& alarm);
 
  void complete_ (bool notify);
 
  bool process_ ();
 
  clock::alarm alarm_;
  notifier_type notify_complete_;
 
  unsigned int pattern_ = 0;
  unsigned int interval_ = 0;
 
  uint8_t flags_ = 0;
 
  uint8_t initial_reps_ = 0;
 
  uint8_t reps_ = 0;
 
  uint8_t idx_ = 0;
};
 
} // namespace led
} // namespace nrfcxx
 
#endif /* NRFCXX_LED_HPP */