Debouncer.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_DEBOUNCER_HXX_
#define _UTILS_DEBOUNCER_HXX_
 
class QuiesceDebouncer
{
public:
    typedef uint8_t Options;
 
    QuiesceDebouncer(const Options &wait_count)
        : count_(0)
        , waitCount_(wait_count)
        , currentState_(0)
    {
    }
 
    void reset_options(const Options &opts)
    {
        waitCount_ = opts;
        initialize(currentState_);
    }
 
    void initialize(bool state)
    {
        currentState_ = state ? 1 : 0;
        count_ = 0;
    }
 
    void override(bool new_state)
    {
        initialize(new_state);
    }
 
    bool current_state()
    {
        return currentState_;
    }
 
    bool update_state(bool state)
    {
        unsigned new_state = state ? 1 : 0;
        if (new_state == currentState_)
        {
            count_ = 0;
            return false;
        }
        if (++count_ == waitCount_)
        {
            currentState_ = new_state;
            count_ = 0;
            return true;
        }
        return false;
    }
 
private:
    unsigned count_ : 8;
    unsigned waitCount_ : 8;
    unsigned currentState_ : 1;
};
 
class CountingDebouncer
{
public:
    typedef struct
    {
        uint8_t window_size;
        uint8_t min_count;
    } Options;
 
    CountingDebouncer(const Options &opts)
        : opts_(opts)
        , lastCount_(0)
        , currentState_(0)
    {
        trim_options();
    }
 
    void reset_options(const Options &opts)
    {
        opts_ = opts;
        trim_options();
        initialize(currentState_);
    }
 
    const Options &options()
    {
        return opts_;
    }
 
    void initialize(bool state)
    {
        if (state) {
            currentState_ = 1;
            window_ = 0xFFFFFFFFu;
            lastCount_ = opts_.window_size;
        } else {
            currentState_ = 0;
            window_ = 0;
            lastCount_ = 0;
        }
    }
 
    void override(bool new_state)
    {
        initialize(new_state);
    }
 
    bool current_state()
    {
        return currentState_;
    }
 
    bool update_state(bool state)
    {
        if (window_ & (1<<(opts_.window_size - 1))) {
            --lastCount_;
        }
        window_ <<= 1;
        if (state) {
            lastCount_++;
            window_ |= 1;
        }
        unsigned new_state = lastCount_ >= opts_.min_count ? 1 : 0;
        if (new_state != currentState_) {
            currentState_ = new_state;
            return true;
        } else {
            return false;
        }
    }
 
private:
    void trim_options()
    {
        if (opts_.window_size > 32)
        {
            opts_.window_size = 32;
        }
        if (opts_.window_size == 0)
        {
            opts_.window_size = 1;
        }
        if (opts_.min_count == 0)
        {
            opts_.min_count = 1;
        }
        if (opts_.min_count > opts_.window_size)
        {
            opts_.min_count = opts_.window_size;
        }
    }
 
    uint32_t window_{0}; 
    Options opts_; 
    unsigned lastCount_ : 6; 
    unsigned currentState_ : 1; 
};
 
template <class Debouncer> class ToggleDebouncer
{
public:
    typedef typename Debouncer::Options Options;
 
    ToggleDebouncer(const Options &options)
        : impl_(options)
        , eventState_(0)
    {
    }
 
    void initialize(bool state)
    {
        // comes from the hardware
        impl_.initialize(state);
    }
 
    void override(bool state)
    {
        eventState_ = state ? 1 : 0;
    }
 
    bool current_state()
    {
        // We ignore the local state and just publish the network state.
        return eventState_;
    }
 
    bool update_state(bool state)
    {
        bool press_changed = impl_.update_state(state);
        // Look for rising edge
        if (press_changed && impl_.current_state())
        {
            // flip desired state and report update
            eventState_ ^= 1;
            return true;
        }
        return false;
    }
 
private:
    Debouncer impl_;
    unsigned eventState_ : 1;
};
 
#endif // _UTILS_DEBOUNCER_HXX_