ConfiguredProducer.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CONFIGUREDPRODUCER_HXX_
#define _OPENLCB_CONFIGUREDPRODUCER_HXX_
 
#include "openlcb/PolledProducer.hxx"
#include "openlcb/EventHandlerTemplates.hxx"
#include "openlcb/ConfigRepresentation.hxx"
#include "utils/ConfigUpdateListener.hxx"
#include "utils/ConfigUpdateService.hxx"
#include "utils/Debouncer.hxx"
 
namespace openlcb
{
 
CDI_GROUP(ProducerConfig);
CDI_GROUP_ENTRY(description, StringConfigEntry<15>, //
                Name("Description"), Description("User name of this input."));
CDI_GROUP_ENTRY(
    debounce, Uint8ConfigEntry, Name("Debounce parameter"),
    Default(3),
    Description("Amount of time to wait for the input to stabilize before "
                "producing the event. Unit is 30 msec of time. Usually a value "
                "of 2-3 works well in a non-noisy environment. In high noise "
                "(train wheels for example) a setting between 8 -- 15 makes "
                "for a slower response time but a more stable "
                "signal.\nFormally, the parameter tells how many times of "
                "tries, each 30 msec apart, the input must have the same value "
                "in order for that value to be accepted and the event "
                "transition produced."),
    Default(3));
CDI_GROUP_ENTRY(
    event_on, EventConfigEntry, //
    Name("Event On"),
    Description("This event will be produced when the input goes to HIGH."));
CDI_GROUP_ENTRY(
    event_off, EventConfigEntry, //
    Name("Event Off"),
    Description("This event will be produced when the input goes to LOW."));
CDI_GROUP_END();
 
extern "C" {
void ignore_fn();
}
 
class ConfiguredProducer : public ConfigUpdateListener
{
public:
    using Impl = GPIOBit;
    using ProducerClass = PolledProducer<QuiesceDebouncer, Impl>;
 
    ConfiguredProducer(Node *node, const ProducerConfig &cfg, const Gpio *gpio)
        : producer_(QuiesceDebouncer::Options(3), node, 0, 0, gpio)
        , cfg_(cfg)
    {
        ConfigUpdateService::instance()->register_update_listener(this);
    }
 
    template <class HW>
    ConfiguredProducer(Node *node, const ProducerConfig &cfg, const HW &,
        const Gpio *g = HW::instance(), decltype(HW::instance) * = 0)
        : producer_(QuiesceDebouncer::Options(3), node, 0, 0, g)
        , cfg_(cfg)
    {
        ConfigUpdateService::instance()->register_update_listener(this);
    }
 
    UpdateAction apply_configuration(int fd, bool initial_load,
                                     BarrierNotifiable *done) override
    {
        AutoNotify n(done);
        uint8_t debounce_arg = cfg_.debounce().read(fd);
        EventId cfg_event_on = cfg_.event_on().read(fd);
        EventId cfg_event_off = cfg_.event_off().read(fd);
        if (cfg_event_off != producer_.event_off() ||
            cfg_event_on != producer_.event_on())
        {
            auto saved_gpio = producer_.gpio_;
            auto saved_node = producer_.node();
            // Need to reinitialize the producer. We do this with in-place
            // destruction and construction.
            producer_.ProducerClass::~ProducerClass();
            new (&producer_) ProducerClass(
                QuiesceDebouncer::Options(debounce_arg), saved_node,
                cfg_event_on, cfg_event_off, saved_gpio);
            return REINIT_NEEDED; // Causes events identify.
        }
        return UPDATED;
    }
 
    void factory_reset(int fd) OVERRIDE
    {
        cfg_.description().write(fd, "");
        CDI_FACTORY_RESET(cfg_.debounce);
    }
 
    Polling *polling()
    {
        return &producer_;
    }
 
private:
    ProducerClass producer_;
    const ProducerConfig cfg_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_CONFIGUREDPRODUCER_HXX_