ExtendedIOElement.hpp

Go to the documentation of this file.

/* ✔ */
 
#pragma once
 
#include <AH/Settings/Warnings.hpp>
AH_DIAGNOSTIC_WERROR() // Enable errors on warnings
 
#include "ExtendedInputOutput.hpp"
#include <AH/Containers/Updatable.hpp>
#include <AH/Hardware/Hardware-Types.hpp>
 
BEGIN_AH_NAMESPACE
 
class ExtendedIOElement : public UpdatableCRTP<ExtendedIOElement> {
  protected:
    ExtendedIOElement(pin_t length);
 
    ExtendedIOElement(const ExtendedIOElement &) = delete;
    ExtendedIOElement &operator=(const ExtendedIOElement &) = delete;
 
    ExtendedIOElement(ExtendedIOElement &&) = default;
    ExtendedIOElement &operator=(ExtendedIOElement &&) = delete;
 
  public:
    virtual void pinMode(pin_t pin, PinMode_t mode) {
        pinModeBuffered(pin, mode);
        updateBufferedOutputs();
    }
 
    virtual void pinModeBuffered(pin_t pin, PinMode_t mode) = 0;
 
    virtual void digitalWrite(pin_t pin, PinStatus_t state) {
        digitalWriteBuffered(pin, state);
        updateBufferedOutputs();
    }
 
    virtual void digitalWriteBuffered(pin_t pin, PinStatus_t state) = 0;
 
    virtual PinStatus_t digitalRead(pin_t pin) {
        updateBufferedInputs();
        return digitalReadBuffered(pin);
    }
 
    virtual PinStatus_t digitalReadBuffered(pin_t pin) = 0;
 
    virtual void analogWrite(pin_t pin, analog_t val) {
        analogWriteBuffered(pin, val);
        updateBufferedOutputs();
    }
 
    virtual void analogWriteBuffered(pin_t pin, analog_t val) = 0;
 
    virtual analog_t analogRead(pin_t pin) {
        updateBufferedInputs();
        return analogReadBuffered(pin);
    }
 
    virtual analog_t analogReadBuffered(pin_t pin) = 0;
 
    virtual void begin() = 0;
 
    static void beginAll();
 
    virtual void updateBufferedOutputs() = 0;
 
    static void updateAllBufferedOutputs();
 
    virtual void updateBufferedInputs() = 0;
 
    static void updateAllBufferedInputs();
 
    pin_t pin(pin_t pin) const;
 
    pin_t operator[](pin_t pin) const;
 
    pin_t getLength() const;
 
    pin_t getEnd() const;
 
    pin_t getStart() const;
 
    static DoublyLinkedList<ExtendedIOElement> &getAll();
 
  private:
    const pin_t length;
    const pin_t start;
    const pin_t end;
    static pin_t offset;
};
 
namespace ExtIO {
 
struct CachedExtIOPin {
    explicit CachedExtIOPin(pin_t pin)
        : element(pin == NO_PIN || isNativePin(pin) ? nullptr
                                                    : getIOElementOfPin(pin)),
          elementPin(element ? pin - element->getStart() : pin) {}
 
    template <class FRet, class... FArgs, class Fallback>
    FRet __attribute__((always_inline))
    apply(FRet (ExtendedIOElement::*func)(pin_t, FArgs...), Fallback &&fallback,
          FArgs... args) {
        if (element != nullptr)
            return (element->*func)(elementPin, args...);
        else if (elementPin != NO_PIN)
            return fallback(arduino_pin_cast(elementPin), args...);
        else
            return static_cast<FRet>(0);
    }
 
    ExtendedIOElement *element;
    pin_t elementPin;
};
 
inline void pinMode(CachedExtIOPin pin, PinMode_t mode) {
    pin.apply(
        &ExtendedIOElement::pinMode, //
        [](ArduinoPin_t p, PinMode_t m) { ::pinMode(p, m); }, mode);
}
inline void digitalWrite(CachedExtIOPin pin, PinStatus_t val) {
    pin.apply(
        &ExtendedIOElement::digitalWrite, //
        [](ArduinoPin_t p, PinStatus_t v) { ::digitalWrite(p, v); }, val);
}
inline PinStatus_t digitalRead(CachedExtIOPin pin) {
    return pin.apply(&ExtendedIOElement::digitalRead, //
                     [](ArduinoPin_t p) { return ::digitalRead(p); });
}
 
inline analog_t analogRead(CachedExtIOPin pin) {
    return pin.apply(&ExtendedIOElement::analogRead, //
                     [](ArduinoPin_t p) { return ::analogRead(p); });
}
inline void analogWrite(CachedExtIOPin pin, analog_t val) {
#ifndef ESP32
    pin.apply(
        &ExtendedIOElement::analogWrite, //
        [](ArduinoPin_t p, analog_t v) { ::analogWrite(p, v); }, val);
#else
    pin.apply(
        &ExtendedIOElement::analogWrite, //
        [](ArduinoPin_t, analog_t) {}, val);
#endif
}
inline void analogWrite(CachedExtIOPin pin, int val) {
    return analogWrite(pin, static_cast<analog_t>(val));
}
 
inline void shiftOut(CachedExtIOPin dataPin, CachedExtIOPin clockPin,
                     BitOrder_t bitOrder, uint8_t val) {
    if (dataPin.elementPin == NO_PIN || clockPin.elementPin == NO_PIN)
        return;
    // Native version
    if (dataPin.element == nullptr && clockPin.element == nullptr) {
        ::shiftOut(arduino_pin_cast(dataPin.elementPin),
                   arduino_pin_cast(clockPin.elementPin), bitOrder, val);
    }
    // ExtIO version
    else if (dataPin.element != nullptr && clockPin.element != nullptr) {
        const auto dataEl = dataPin.element;
        const auto dataPinN = dataPin.elementPin;
        const auto clockEl = clockPin.element;
        const auto clockPinN = clockPin.elementPin;
        for (uint8_t i = 0; i < 8; i++) {
            uint8_t mask = bitOrder == LSBFIRST ? (1 << i) : (1 << (7 - i));
            dataEl->digitalWrite(dataPinN, (val & mask) ? HIGH : LOW);
            clockEl->digitalWrite(clockPinN, HIGH);
            clockEl->digitalWrite(clockPinN, LOW);
        }
    }
    // Mixed version (slow)
    else {
        for (uint8_t i = 0; i < 8; i++) {
            uint8_t mask = bitOrder == LSBFIRST ? (1 << i) : (1 << (7 - i));
            digitalWrite(dataPin, (val & mask) ? HIGH : LOW);
            digitalWrite(clockPin, HIGH);
            digitalWrite(clockPin, LOW);
        }
    }
}
 
inline void pinModeBuffered(CachedExtIOPin pin, PinMode_t mode) {
    pin.apply(
        &ExtendedIOElement::pinModeBuffered, //
        [](ArduinoPin_t p, PinMode_t m) { ::pinMode(p, m); }, mode);
}
inline void digitalWriteBuffered(CachedExtIOPin pin, PinStatus_t val) {
    pin.apply(
        &ExtendedIOElement::digitalWriteBuffered, //
        [](ArduinoPin_t p, PinStatus_t v) { ::digitalWrite(p, v); }, val);
}
inline PinStatus_t digitalReadBuffered(CachedExtIOPin pin) {
    return pin.apply(&ExtendedIOElement::digitalReadBuffered, //
                     [](ArduinoPin_t p) { return ::digitalRead(p); });
}
 
inline analog_t analogReadBuffered(CachedExtIOPin pin) {
    return pin.apply(&ExtendedIOElement::analogReadBuffered, //
                     [](ArduinoPin_t p) { return ::analogRead(p); });
}
inline void analogWriteBuffered(CachedExtIOPin pin, analog_t val) {
#ifndef ESP32
    pin.apply(
        &ExtendedIOElement::analogWriteBuffered, //
        [](ArduinoPin_t p, analog_t v) { ::analogWrite(p, v); }, val);
#else
    pin.apply(
        &ExtendedIOElement::analogWriteBuffered, //
        [](ArduinoPin_t, analog_t) {}, val);
#endif
}
inline void analogWriteBuffered(CachedExtIOPin pin, int val) {
    return analogWrite(pin, static_cast<analog_t>(val));
}
} // namespace ExtIO
 
using ExtIO::CachedExtIOPin;
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()