cached_gpio.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <cstring>
#include <limits>
#include <type_traits>
#include "esphome/core/hal.h"
 
namespace esphome::gpio_expander {
 
template<typename T, uint16_t N, typename P = typename std::conditional<(N > 256), uint16_t, uint8_t>::type>
class CachedGpioExpander {
 public:
  bool digital_read(P pin) {
    const P bank = pin / BANK_SIZE;
    const T pin_mask = (1 << (pin % BANK_SIZE));
    // Check if specific pin cache is valid
    if (this->read_cache_valid_[bank] & pin_mask) {
      if (this->invalidate_on_read_) {
        // Invalidate pin so next read triggers hardware read
        this->read_cache_valid_[bank] &= ~pin_mask;
      }
    } else {
      // Read whole bank from hardware
      if (!this->digital_read_hw(pin))
        return false;
      // Mark bank cache as valid except the pin that is being returned now
      // (when not invalidating on read, mark all pins including this one as valid)
      this->read_cache_valid_[bank] = std::numeric_limits<T>::max() & ~(this->invalidate_on_read_ ? pin_mask : 0);
    }
    return this->digital_read_cache(pin);
  }
 
  void digital_write(P pin, bool value) { this->digital_write_hw(pin, value); }
 
 protected:
  virtual bool digital_read_hw(P pin) = 0;
 
  virtual bool digital_read_cache(P pin) = 0;
 
  virtual void digital_write_hw(P pin, bool value) = 0;
 
  void reset_pin_cache_() { memset(this->read_cache_valid_, 0x00, CACHE_SIZE_BYTES); }
 
  void set_invalidate_on_read_(bool invalidate) { this->invalidate_on_read_ = invalidate; }
 
  static constexpr uint16_t BITS_PER_BYTE = 8;
  static constexpr uint16_t BANK_SIZE = sizeof(T) * BITS_PER_BYTE;
  static constexpr size_t BANKS = N / BANK_SIZE;
  static constexpr size_t CACHE_SIZE_BYTES = BANKS * sizeof(T);
 
  T read_cache_valid_[BANKS]{0};
  bool invalidate_on_read_{true};
};
 
}  // namespace esphome::gpio_expander