AnalogMultiplex.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 "StaticSizeExtendedIOElement.hpp"
#include <AH/Containers/Array.hpp>
#include <stdlib.h>
 
BEGIN_AH_NAMESPACE
 
template <uint8_t N>
class AnalogMultiplex : public StaticSizeExtendedIOElement<1 << N> {
  public:
    AnalogMultiplex(pin_t analogPin, const Array<pin_t, N> &addressPins,
                    pin_t enablePin = NO_PIN)
        : analogPin(analogPin), addressPins(addressPins), enablePin(enablePin) {
    }
 
    void pinMode(pin_t pin, PinMode_t mode) override;
 
    void pinModeBuffered(pin_t pin, PinMode_t mode) override;
 
    void digitalWrite(pin_t, PinStatus_t) override // LCOV_EXCL_LINE
        __attribute__((deprecated)) {}             // LCOV_EXCL_LINE
 
    void digitalWriteBuffered(pin_t, PinStatus_t) override // LCOV_EXCL_LINE
        __attribute__((deprecated)) {}                     // LCOV_EXCL_LINE
 
    PinStatus_t digitalRead(pin_t pin) override;
 
    PinStatus_t digitalReadBuffered(pin_t pin) override;
 
    analog_t analogRead(pin_t pin) override;
 
    analog_t analogReadBuffered(pin_t pin) override;
 
    void analogWrite(pin_t, analog_t) override // LCOV_EXCL_LINE
        __attribute__((deprecated)) {}         // LCOV_EXCL_LINE
 
    void analogWriteBuffered(pin_t, analog_t) override // LCOV_EXCL_LINE
        __attribute__((deprecated)) {}                 // LCOV_EXCL_LINE
 
    void begin() override;
 
    void updateBufferedOutputs() override {} // LCOV_EXCL_LINE
 
    void updateBufferedInputs() override {} // LCOV_EXCL_LINE
 
    void discardFirstReading(bool discardFirstReading_) {
        this->discardFirstReading_ = discardFirstReading_;
    }
 
  protected:
    const pin_t analogPin;
    const Array<pin_t, N> addressPins;
    const pin_t enablePin;
    bool discardFirstReading_ = true;
 
    void setMuxAddress(uint8_t address);
 
    void prepareReading(uint8_t address);
 
    void afterReading();
 
    // The enable pin is active low.
    constexpr static auto MUX_ENABLED = LOW;
    constexpr static auto MUX_DISABLED = HIGH;
};
 
using CD74HC4067 = AnalogMultiplex<4>;
 
using CD74HC4051 = AnalogMultiplex<3>;
 
// -------------------------------------------------------------------------- //
 
template <uint8_t N>
void AnalogMultiplex<N>::pinMode(pin_t, PinMode_t mode) {
    ExtIO::pinMode(analogPin, mode);
}
 
template <uint8_t N>
void AnalogMultiplex<N>::pinModeBuffered(pin_t, PinMode_t mode) {
    AnalogMultiplex<N>::pinMode(analogPin, mode);
}
 
template <uint8_t N>
PinStatus_t AnalogMultiplex<N>::digitalRead(pin_t pin) {
    prepareReading(pin);
    PinStatus_t result = ExtIO::digitalRead(analogPin);
    afterReading();
    return result;
}
 
template <uint8_t N>
PinStatus_t AnalogMultiplex<N>::digitalReadBuffered(pin_t pin) {
    return AnalogMultiplex<N>::digitalRead(pin);
}
 
template <uint8_t N>
analog_t AnalogMultiplex<N>::analogRead(pin_t pin) {
    prepareReading(pin);
    if (discardFirstReading_)
        (void)ExtIO::analogRead(analogPin); // Discard first reading
    analog_t result = ExtIO::analogRead(analogPin);
    afterReading();
    return result;
}
 
template <uint8_t N>
analog_t AnalogMultiplex<N>::analogReadBuffered(pin_t pin) {
    return AnalogMultiplex<N>::analogRead(pin);
}
 
template <uint8_t N>
void AnalogMultiplex<N>::begin() {
    for (const pin_t &addressPin : addressPins)
        ExtIO::pinMode(addressPin, OUTPUT);
    if (enablePin != NO_PIN) {
        ExtIO::pinMode(enablePin, OUTPUT);
        ExtIO::digitalWrite(enablePin, MUX_DISABLED);
    }
}
 
template <uint8_t N>
void AnalogMultiplex<N>::setMuxAddress(uint8_t address) {
    uint8_t mask = 1;
    for (const pin_t &addressPin : addressPins) {
        ExtIO::digitalWrite(addressPin, (address & mask) != 0 ? HIGH : LOW);
        mask <<= 1;
    }
#if !defined(__AVR__) && defined(ARDUINO)
    delayMicroseconds(1);
#endif
}
 
template <uint8_t N>
void AnalogMultiplex<N>::prepareReading(uint8_t address) {
    setMuxAddress(address);
    if (enablePin != NO_PIN)
        ExtIO::digitalWrite(enablePin, MUX_ENABLED);
}
 
template <uint8_t N>
void AnalogMultiplex<N>::afterReading() {
    if (enablePin != NO_PIN)
        ExtIO::digitalWrite(enablePin, MUX_DISABLED);
}
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()