input.hpp

#ifndef QOS_EDGE_CHECK
#define QOS_EDGE_CHECK
 
#include "include/types.hpp"
#include "include/list.hpp"
#include "include/timer.hpp"
#include "include/helper.hpp"
 
namespace qOS {
 


    namespace input {

        class watcher;
        class channel;


        enum class event {
            NONE = 0,
            EXCEPTION,              
            ON_CHANGE,              
            FALLING_EDGE,           
            RISING_EDGE,            
            PULSATION_DOUBLE,       
            PULSATION_TRIPLE,       
            PULSATION_MULTI,        
            HIGH_THRESHOLD,         
            LOW_THRESHOLD,          
            IN_BAND,                
            STEADY_IN_HIGH,         
            STEADY_IN_LOW,          
            STEADY_IN_BAND,         
            DELTA,                  
            STEP_UP,                
            STEP_DOWN,              
            MAX_EVENTS,
            STEP = STEP_UP
        };

        enum class type {
            DIGITAL_CHANNEL,            
            ANALOG_CHANNEL,             
        };
 
 
        using digitalValue_t = int;
        using analogValue_t = uint32_t;

        using digitalReaderFcn_t = digitalValue_t (*)( uint8_t );

        using analogReaderFcn_t = analogValue_t (*)( uint8_t );
 
 

        using eventCallback_t = void(*)( channel& );
 
        class channel : protected node {
            protected:
                event lastEvent{ event::NONE };
                uint8_t number;
                void *userData{ nullptr };
                eventCallback_t callback{ nullptr };
                qOS::clock_t tChange{ 0U };
                qOS::clock_t tSteadyHigh{ 0xFFFFFFFFU };
                qOS::clock_t tSteadyLow{ 0xFFFFFFFFU };
                virtual void updateReading( bool act ) noexcept = 0;
                virtual void evaluateState( void ) noexcept = 0;
                virtual bool isValidConfig( void ) const noexcept = 0;
                virtual void setInitalState( void ) noexcept = 0;
                inline void dispatchEvent( event e ) noexcept
                {
                    lastEvent = e;
                    callback( *this );
                }
            public:
                virtual ~channel() {}
                channel( uint8_t channelNumber ) : number( channelNumber ) {}

                virtual type getType( void ) const noexcept = 0;
                inline event getEvent( void ) const noexcept
                {
                    return lastEvent;
                }

                inline bool setCallback( const eventCallback_t cb ) noexcept
                {
                    callback = cb;
                    return ( cb != callback );
                }

                inline bool setChannel( const uint8_t inputChannel ) noexcept
                {
                    bool retValue = false;
 
                    if ( inputChannel < 32U ) {
                        number = inputChannel;
                        retValue = true;
                    }
 
                    return retValue;
                }

                inline uint8_t getChannel( void ) const noexcept
                {
                    return number;
                }

                inline void setUserData( void* pUserData ) noexcept
                {
                    userData = pUserData;
                }

                inline void* getUserData( void ) noexcept
                {
                    return userData;
                }

                virtual bool isShared( void ) const noexcept = 0;
                virtual bool setTime( const event e, const qOS::duration_t t ) noexcept = 0;
                virtual bool setParameter( const event e, const analogValue_t p ) noexcept = 0;
                virtual uint8_t getCount( void ) const noexcept = 0;
                virtual bool setReader( digitalReaderFcn_t r ) noexcept = 0;
                virtual bool setReader( analogReaderFcn_t r ) noexcept = 0;
 
                virtual bool unShare( void ) noexcept = 0;
                friend class watcher;
        };
 

        class digitalChannel : public channel {
            using channelStateFcn_t = void(*)( digitalChannel& );
            private:
                digitalValue_t value{ 0 };
                digitalValue_t *ptrValue{ &value };
                digitalReaderFcn_t reader{ nullptr };
                channelStateFcn_t channelState{ nullptr };
                bool negate{ false };
                qOS::clock_t pulsationInterval{ 250U };
                uint8_t pulsationCount{ 0 };
                void updateReading( bool act ) noexcept override;
                void setInitalState( void ) noexcept override;
                bool isValidConfig( void ) const noexcept override
                {
                    return true;
                }
                void evaluateState( void ) noexcept override
                {
                    channelState( *this );
                }
                static void fallingEdgeState( digitalChannel& c );
                static void risingEdgeState( digitalChannel& c );
                static void steadyInHighState( digitalChannel& c );
                static void steadyInLowState( digitalChannel& c );
                digitalChannel( digitalChannel const& ) = delete;
                void operator=( digitalChannel const& ) = delete;
            public:
                virtual ~digitalChannel() {}
                digitalChannel( const uint8_t inputChannel, bool invert = false ) : channel( inputChannel ), negate( invert) {}
                type getType( void ) const noexcept override
                {
                    return type::DIGITAL_CHANNEL;
                }

                bool setTime( const event e, const qOS::duration_t t ) noexcept override;
                bool setParameter( const event e, const analogValue_t p ) noexcept override;
                uint8_t getCount( void ) const noexcept override
                {
                    return pulsationCount;
                }

                bool isShared( void ) const noexcept override
                {
                    return ( &value != ptrValue );
                }

                bool setReader( digitalReaderFcn_t r ) noexcept override
                {
                    reader = r;
                    return true;
                }

                bool setReader( analogReaderFcn_t r ) noexcept override
                {
                    (void)r;
                    return false;
                }
                bool unShare( void ) noexcept override
                {
                    ptrValue = &value;
                    return true;
                }
            friend class watcher;
        };

        class analogChannel : public channel {
            using channelStateFcn_t = void(*)( analogChannel& );
            private:
                analogValue_t value{ 0 };
                analogValue_t *ptrValue{ &value };
                analogReaderFcn_t reader{ nullptr };
                channelStateFcn_t channelState{ nullptr };
                analogValue_t high{ 800U };
                analogValue_t low{ 200U };
                analogValue_t lastStep{ 0U };
                analogValue_t lastSampled{ 0U };
                analogValue_t delta{ 0xFFFFFFFFU };
                analogValue_t step{ 0xFFFFFFFFU };
                analogValue_t hysteresis{ 20U };
                qOS::clock_t tSteadyBand{ 0xFFFFFFFFU };
 
                void updateReading( bool act ) noexcept override;
                void setInitalState( void ) noexcept override;
                bool isValidConfig( void ) const noexcept override
                {
                    return ( high - low ) > hysteresis;
                }
                void evaluateState( void ) noexcept override
                {
                    channelState( *this );
                }
                static void lowThresholdState( analogChannel& c );
                static void highThresholdState( analogChannel& c );
                static void inBandState( analogChannel& c );
                static void steadyInHighState( analogChannel& c );
                static void steadyInLowState( analogChannel& c );
                static void steadyInBandState( analogChannel& c );
                analogChannel( analogChannel const& ) = delete;
                void operator=( analogChannel const& ) = delete;
            public:
                virtual ~analogChannel() {}
                analogChannel( const uint8_t inputChannel, const analogValue_t lowerThreshold, const analogValue_t upperThreshold, const analogValue_t h = 20 )
                : channel( inputChannel ),
                  high( upperThreshold ),
                  low( lowerThreshold ),
                  hysteresis( h ) {}

                type getType( void ) const noexcept override
                {
                    return type::ANALOG_CHANNEL;
                }

                bool setTime( const event e, const qOS::duration_t t ) noexcept override;
                bool setParameter( const event e, const analogValue_t p ) noexcept override;
                uint8_t getCount( void ) const noexcept override
                {
                    return 0;
                }

                bool isShared( void ) const noexcept override
                {
                    return ( &value != ptrValue );
                }

                bool setReader( digitalReaderFcn_t r ) noexcept override
                {
                    (void)r;
                    return false;
                }
                bool setReader( analogReaderFcn_t r ) noexcept override
                {
                    reader = r;
                    return true;
                }

                bool unShare( void ) noexcept override
                {
                    ptrValue = &value;
                    return true;
                }
            friend class watcher;
        };
 

        class watcher : protected node {
            private:
                eventCallback_t exception{ nullptr };
                list digitalChannels;
                list analogChannels;
                qOS::timer waitDebounce;
                qOS::duration_t debounceTime{ 100_ms };
                digitalReaderFcn_t digitalReader{ nullptr };
                analogReaderFcn_t analogReader{ nullptr };
                watcher( watcher const& ) = delete;
                void operator=( watcher const& ) = delete;
            public:
                virtual ~watcher() {}
                watcher( const qOS::duration_t dt = 100_ms ) : debounceTime( dt ) {}
                watcher( const digitalReaderFcn_t& rDigital, const analogReaderFcn_t& rAnalog, const qOS::duration_t timeDebounce = 100_ms ) :
                    debounceTime( timeDebounce ), digitalReader( rDigital ), analogReader( rAnalog ) {}

                bool add( channel& c ) noexcept;
                inline bool add( channel& c, eventCallback_t cb ) noexcept
                {
                    (void)c.setCallback( cb );
                    return add( c );
                }

                inline bool add( channel&c, digitalReaderFcn_t fcn, eventCallback_t cb ) noexcept
                {
                    bool retValue;
                    (void)c.setCallback( cb );
                    retValue = add( c );
                    (void)c.setReader( fcn );
                    return retValue;
                }

                inline bool add( channel&c, analogReaderFcn_t fcn, eventCallback_t cb ) noexcept
                {
                    bool retValue;
                    (void)c.setCallback( cb );
                    retValue = add( c );
                    (void)c.setReader( fcn );
                    return retValue;
                }

                bool remove( channel& c ) noexcept;
                bool watch( void ) noexcept;
                inline bool operator()( void )
                {
                    return watch();
                }
        };

    }

}
 
#endif /*QOS_EDGE_CHECK*/