95 lines
4.3 KiB
C++
95 lines
4.3 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <type_traits>
|
|
#include "esphome/core/hal.h"
|
|
|
|
namespace esphome::gpio_expander {
|
|
|
|
/// @brief A class to cache the read state of a GPIO expander.
|
|
/// This class caches reads between GPIO Pins which are on the same bank.
|
|
/// This means that for reading whole Port (ex. 8 pins) component needs only one
|
|
/// I2C/SPI read per main loop call. It assumes that one bit in byte identifies one GPIO pin.
|
|
///
|
|
/// Template parameters:
|
|
/// T - Type which represents internal bank register. Could be uint8_t or uint16_t.
|
|
/// Choose based on how your I/O expander reads pins:
|
|
/// * uint8_t: For chips that read banks separately (8 pins at a time)
|
|
/// Examples: MCP23017 (2x8-bit banks), TCA9555 (2x8-bit banks)
|
|
/// * uint16_t: For chips that read all pins at once (up to 16 pins)
|
|
/// Examples: PCF8574/8575 (8/16 pins), PCA9554/9555 (8/16 pins)
|
|
/// N - Total number of pins (maximum 65535)
|
|
/// P - Type for pin number parameters (automatically selected based on N:
|
|
/// uint8_t for N<=256, uint16_t for N>256). Can be explicitly specified
|
|
/// if needed (e.g., for components like SN74HC165 with >256 pins)
|
|
template<typename T, uint16_t N, typename P = typename std::conditional<(N > 256), uint16_t, uint8_t>::type>
|
|
class CachedGpioExpander {
|
|
public:
|
|
/// @brief Read the state of the given pin.
|
|
/// By default, each read invalidates the pin's cache entry so the next read
|
|
/// of the same pin triggers a fresh hardware read. When invalidate_on_read
|
|
/// is disabled, the cache stays valid until explicitly cleared via reset_pin_cache_().
|
|
/// @param pin Pin number to read
|
|
/// @return Pin state
|
|
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:
|
|
/// @brief Read GPIO bank from hardware into internal state
|
|
/// @param pin Pin number (used to determine which bank to read)
|
|
/// @return true if read succeeded, false on communication error
|
|
/// @note This does NOT return the pin state. It returns whether the read operation succeeded.
|
|
/// The actual pin state should be returned by digital_read_cache().
|
|
virtual bool digital_read_hw(P pin) = 0;
|
|
|
|
/// @brief Get cached pin value from internal state
|
|
/// @param pin Pin number to read
|
|
/// @return Pin state (true = HIGH, false = LOW)
|
|
virtual bool digital_read_cache(P pin) = 0;
|
|
|
|
/// @brief Write GPIO state to hardware
|
|
/// @param pin Pin number to write
|
|
/// @param value Pin state to write (true = HIGH, false = LOW)
|
|
virtual void digital_write_hw(P pin, bool value) = 0;
|
|
|
|
/// @brief Invalidate cache. This function should be called in component loop().
|
|
void reset_pin_cache_() { memset(this->read_cache_valid_, 0x00, CACHE_SIZE_BYTES); }
|
|
|
|
/// @brief Control whether digital_read() invalidates the pin's cache entry after reading.
|
|
/// When enabled (default), each read self-invalidates so the next read triggers a hardware read.
|
|
/// When disabled, cache stays valid until reset_pin_cache_() is explicitly called.
|
|
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
|