Line data    Source code

       1              : /* ✔ */
       2              : 
       3              : #pragma once
       4              : 
       5              : #include <AH/Containers/Array.hpp>
       6              : #include <AH/PrintStream/PrintStream.hpp>
       7              : #include <AH/STL/limits>
       8              : #include <AH/Settings/NamespaceSettings.hpp>
       9              : #include <stdint.h> // uint8_t
      10              : 
      11              : BEGIN_AH_NAMESPACE
      12              : 
      13              : /// The type returned from analogRead and similar functions.
      14              : using analog_t = uint16_t;
      15              : /// Integer type used internally to store the index of (extended) GPIO pins.
      16              : /// This type is also used to represent _offsets_ of pin
      17              : /// numbers (e.g. the index of a pin within an extended IO element).
      18              : /// In contrast, @ref ExtIO::pin_t represents an _absolute_ pin number.
      19              : using pin_int_t = uint_fast16_t;
      20              : constexpr pin_int_t NO_PIN_INT =
      21              :     (std::numeric_limits<pin_int_t>::max() >> 1) + 1;
      22              : 
      23              : namespace ExtIO {
      24              : /// Type for storing pin numbers of Extended Input/Output elements.
      25              : struct pin_t {
      26              :     /// Default constructor (NO_PIN).
      27              :     constexpr pin_t() = default;
      28              :     /// Constructor from integer.
      29          218 :     constexpr pin_t(pin_int_t pin) : pin(pin) {}
      30              : 
      31              :     /// The actual underlying pin number.
      32              :     pin_int_t pin = NO_PIN_INT;
      33              : 
      34              :     static_assert(std::is_unsigned<decltype(pin)>::value,
      35              :                   "Error: pin_t should be an unsigned integer type");
      36              : 
      37              :     pin_t &operator+=(pin_int_t b) {
      38              :         this->pin += b;
      39              :         return *this;
      40              :     }
      41              :     pin_t &operator++() {
      42              :         ++pin;
      43              :         return *this;
      44              :     }
      45              :     pin_t operator++(int) {
      46              :         pin_t t = *this;
      47              :         ++pin;
      48              :         return t;
      49              :     }
      50              : 
      51              :     pin_t &operator-=(pin_int_t b) {
      52              :         this->pin -= b;
      53              :         return *this;
      54              :     }
      55              :     pin_t &operator--() {
      56              :         --pin;
      57              :         return *this;
      58              :     }
      59              :     pin_t operator--(int) {
      60              :         pin_t t = *this;
      61              :         --pin;
      62              :         return t;
      63              :     }
      64              : };
      65          909 : constexpr inline bool operator==(pin_t a, pin_t b) { return a.pin == b.pin; }
      66          181 : constexpr inline bool operator<(pin_t a, pin_t b) { return a.pin < b.pin; }
      67              : constexpr inline bool operator<=(pin_t a, pin_t b) { return a.pin <= b.pin; }
      68           48 : constexpr inline bool operator>(pin_t a, pin_t b) { return a.pin > b.pin; }
      69           90 : constexpr inline bool operator>=(pin_t a, pin_t b) { return a.pin >= b.pin; }
      70           38 : constexpr inline bool operator!=(pin_t a, pin_t b) { return !(a == b); }
      71           78 : constexpr inline pin_int_t operator-(pin_t a, pin_t b) { return a.pin - b.pin; }
      72              : constexpr inline pin_t operator-(pin_t a, pin_int_t b) { return a.pin - b; }
      73           49 : constexpr inline pin_t operator+(pin_t a, pin_int_t b) { return a.pin + b; }
      74           70 : constexpr inline pin_t operator+(pin_int_t a, pin_t b) { return a + b.pin; }
      75              : constexpr inline pin_t operator*(pin_t a, pin_int_t b) { return a.pin * b; }
      76              : constexpr inline pin_t operator*(pin_int_t a, pin_t b) { return a * b.pin; }
      77              : inline Print &operator<<(Print &os, pin_t p) {
      78              :     using AH::operator<<;
      79              :     return os << +p.pin;
      80              : }
      81              : #ifndef ARDUINO
      82            0 : inline std::ostream &operator<<(std::ostream &os, pin_t p) {
      83            0 :     return os << +p.pin;
      84              : }
      85              : #endif
      86              : } // namespace ExtIO
      87              : 
      88              : /// The type for Arduino pins (and ExtendedIOElement pins).
      89              : using ExtIO::pin_t;
      90              : 
      91              : #ifdef NO_PIN // Fix for FastLED: https://github.com/FastLED/FastLED/issues/893
      92              : #undef NO_PIN
      93              : #endif
      94              : 
      95              : /// A special pin number that indicates an unused or invalid pin.
      96              : constexpr pin_t NO_PIN {};
      97              : 
      98              : /// An easy alias for arrays of pins.
      99              : template <size_t N>
     100              : using PinList = Array<pin_t, N>;
     101              : 
     102              : END_AH_NAMESPACE