Charlieplex.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_CHARLIEPLEXING_HXX_
#define _UTILS_CHARLIEPLEXING_HXX_
 
#include "os/Gpio.hxx"
#include "utils/Fixed16.hxx"
#include "utils/Uninitialized.hxx"
 
template <unsigned N> struct CharlieplexHelper;
 
template <> struct CharlieplexHelper<3>
{
    static const uint8_t pinlist[];
    static unsigned num_bits()
    {
        return 6;
    }
 
    static unsigned pin_high(unsigned bit)
    {
        return pinlist[bit << 1];
    }
    static unsigned pin_low(unsigned bit)
    {
        return pinlist[(bit << 1) | 1];
    }
};
 
const uint8_t CharlieplexHelper<3>::pinlist[] = {
    0, 2, //
    0, 1, //
    1, 2, //
    1, 0, //
    2, 1, //
    2, 0, //
};
 
template <> struct CharlieplexHelper<4>
{
    static const uint8_t pinlist[];
    static constexpr unsigned num_bits()
    {
        return 12;
    }
 
    static unsigned pin_high(unsigned bit)
    {
        return pinlist[bit << 1];
    }
    static unsigned pin_low(unsigned bit)
    {
        return pinlist[(bit << 1) | 1];
    }
};
 
const uint8_t CharlieplexHelper<4>::pinlist[] = {
    3, 0, //
    2, 0, //
    1, 0, //
    3, 1, //
    3, 2, //
    2, 1, //
    2, 3, //
    1, 2, //
    0, 2, //
    0, 3, //
    0, 1, //
    1, 3, //
};
 
template <unsigned N, class helper = CharlieplexHelper<N>> class Charlieplex
{
public:
    Charlieplex(const Gpio *const pins[N])
        : pins_(pins)
        , nextBit_(0)
        , bits_(0)
    {
        for (unsigned i = 0; i < N; ++i)
        {
            pins_[i]->set_direction(Gpio::Direction::DINPUT);
        }
    }
 
    void tick()
    {
        pins_[helper::pin_high(nextBit_)]->set_direction(
            Gpio::Direction::DINPUT);
        pins_[helper::pin_low(nextBit_)]->set_direction(Gpio::Direction::DINPUT);
        nextBit_++;
        if (nextBit_ >= helper::num_bits()) {
            nextBit_ = 0;
        }
        if (bits_ & (1 << nextBit_))
        {
            pins_[helper::pin_high(nextBit_)]->set_direction(
                Gpio::Direction::DOUTPUT);
            pins_[helper::pin_high(nextBit_)]->set();
            pins_[helper::pin_low(nextBit_)]->set_direction(
                Gpio::Direction::DOUTPUT);
            pins_[helper::pin_low(nextBit_)]->clr();
        }
    }
 
    unsigned *payload()
    {
        return &bits_;
    }
 
private:
    const Gpio *const *pins_; 
    unsigned nextBit_;        
    unsigned bits_;           
};
 
template <unsigned N, class helper = CharlieplexHelper<N>> class WeightedCharlieplex
{
public:
    WeightedCharlieplex(const Gpio *const pins[helper::num_bits()])
        : pins_(pins)
        , nextBit_(0)
        , bits_(0)
    {
        for (unsigned i = 0; i < N; ++i)
        {
            pins_[i]->set_direction(Gpio::Direction::DINPUT);
        }
        for (unsigned i = 0; i < helper::num_bits(); ++i) {
            actualIntensity_[i].emplace(0);
            desiredIntensity_[i] = 0;
        }
    }
 
    void tick()
    {
        pins_[helper::pin_high(nextBit_)]->set_direction(
            Gpio::Direction::DINPUT);
        pins_[helper::pin_low(nextBit_)]->set_direction(Gpio::Direction::DINPUT);
        nextBit_++;
        if (nextBit_ >= helper::num_bits()) {
            nextBit_ = 0;
        }
        bool lit = false;
        if (bits_ & (1 << nextBit_))
        {
            lit = true;
        }
        else if (desiredIntensity_[nextBit_] > 0)
        {
            (*actualIntensity_[nextBit_]) *= EWMA_RATIO;
            if (actualIntensity_[nextBit_]->round() <
                desiredIntensity_[nextBit_])
            {
                lit = true;
                (*actualIntensity_[nextBit_]) += EWMA_SUM;
            }
        }
        if (lit)
        {
            pins_[helper::pin_high(nextBit_)]->set_direction(
                Gpio::Direction::DOUTPUT);
            pins_[helper::pin_high(nextBit_)]->set();
            pins_[helper::pin_low(nextBit_)]->set_direction(
                Gpio::Direction::DOUTPUT);
            pins_[helper::pin_low(nextBit_)]->clr();
        }
    }
 
    unsigned *payload()
    {
        return &bits_;
    }
 
    uint8_t *desired_intensity()
    {
        return desiredIntensity_;
    }
 
private:
    static constexpr Fixed16 EWMA_RATIO{0, 0xF000};
    static constexpr Fixed16 EWMA_SUM{16, 0};
    
    const Gpio *const *pins_; 
    unsigned nextBit_;        
    unsigned bits_;           
    uint8_t desiredIntensity_[helper::num_bits()]; 
    uninitialized<Fixed16> actualIntensity_[helper::num_bits()]; 
};
 
template<unsigned N, typename helper>
constexpr Fixed16 WeightedCharlieplex<N, helper>::EWMA_SUM;
 
#endif // _UTILS_CHARLIEPLEXING_HXX_