connection_event_callback.hpp

#ifndef BLUETOE_LINK_LAYER_CONNECTION_EVENT_CALLBACK_HPP
#define BLUETOE_LINK_LAYER_CONNECTION_EVENT_CALLBACK_HPP
 
#include <bluetoe/ll_meta_types.hpp>
#include <bluetoe/delta_time.hpp>
 
namespace bluetoe {
namespace link_layer {
 
    namespace details {
        struct connection_event_callback_meta_type : details::valid_link_layer_option_meta_type {};
        struct synchronized_connection_event_callback_meta_type : details::valid_link_layer_option_meta_type {};
        struct check_synchronized_connection_event_callback_meta_type : details::valid_link_layer_option_meta_type {};
 
        struct default_connection_event_callback
        {
            static void call_connection_event_callback( const delta_time& )
            {
            }
 
            typedef connection_event_callback_meta_type meta_type;
        };
    }
 
    template < typename T, T& Obj, unsigned RequiredTimeMS = 0 >
    struct connection_event_callback
    {
        static void call_connection_event_callback( const delta_time& time_till_next_event )
        {
            if ( RequiredTimeMS == 0 || time_till_next_event >= delta_time::msec( RequiredTimeMS ) )
                Obj.ll_connection_event_happend();
        }
 
        typedef details::connection_event_callback_meta_type meta_type;
    };
 
    template < typename T, T& Obj, unsigned MaximumPeriodUS, int PhaseShiftUS, unsigned MaximumExecutionTimeUS = 100 >
    struct synchronized_connection_event_callback
    {
        void stop_synchronized_connection_event_callbacks();
 
        void restart_synchronized_connection_event_callbacks();
 
        void force_synchronized_connection_event_callback();
 
        template < typename LinkLayer >
        struct impl {
            impl()
                : stopped_( false )
                , force_( false )
            {
                static_assert( LinkLayer::hardware_supports_synchronized_user_timer, "choosen binding does not support the use of user timer!" );
            }
 
            void stop_synchronized_connection_event_callbacks()
            {
                stopped_ = true;
                force_   = false;
 
                link_layer().cancel_synchronized_user_timer();
            }
 
            void restart_synchronized_connection_event_callbacks()
            {
                instance_         = 0;
                latency_          = 0;
                num_intervals_since_anchor_moved_ = 0;
 
                stopped_ = false;
                link_layer().restart_user_timer();
            }
 
            void force_synchronized_connection_event_callback()
            {
                force_ = true;
            }
 
            void synchronized_connection_event_callback_new_connection( delta_time connection_interval )
            {
                if ( stopped_ )
                    return;
 
                connection_value_ = typename T::connection();
                instance_         = PhaseShiftUS > 0 ? 1 : 0;
                latency_          = 0;
 
                calculate_effective_period( connection_interval );
                call_ll_connect< T >( connection_interval, connection_value_ );
                link_layer().cancel_synchronized_user_timer();
                setup_timer( first_timeout() );
            }
 
            void synchronized_connection_event_callback_start_changing_connection()
            {
                link_layer().cancel_synchronized_user_timer();
            }
 
            void synchronized_connection_event_callback_connection_changed( delta_time connection_interval )
            {
                if ( stopped_ )
                    return;
 
                instance_         = PhaseShiftUS > 0 ? 1 : 0;
                latency_          = 0;
 
                calculate_effective_period( connection_interval );
                call_ll_update< T >( connection_interval );
                setup_timer( first_timeout() );
            }
 
            void synchronized_connection_event_callback_disconnect()
            {
                call_ll_disconnect< T >( 0 );
                link_layer().cancel_synchronized_user_timer();
            }
 
            void synchronized_connection_event_callback_timeout( bool anchor_moved )
            {
                if ( stopped_ )
                    return;
 
                if ( force_ )
                {
                    force_   = false;
                    latency_ = 0;
                }
 
                latency_ = latency_ == 0
                    ? Obj.ll_synchronized_callback( instance_, connection_value_ )
                    : latency_ - 1;
 
                if ( num_calls_ )
                    instance_ = ( instance_ + 1 ) % num_calls_;
 
                // if the PhaseShiftUS is negative, the first callback is already first_timeout()
                // away from the anchor
                static constexpr unsigned first_interval_after_anchor = ( PhaseShiftUS < 0 )
                    ? 1
                    : 0;
 
                num_intervals_since_anchor_moved_ = anchor_moved
                    ? first_interval_after_anchor
                    : num_intervals_since_anchor_moved_ + 1;
 
                setup_timer( first_timeout() + num_intervals_since_anchor_moved_ * effective_period_ );
            }
 
        private:
            template < class TT >
            auto call_ll_connect( bluetoe::link_layer::delta_time connection_interval, typename TT::connection& con )
                -> decltype(&TT::ll_synchronized_callback_connect)
            {
                con = Obj.ll_synchronized_callback_connect( connection_interval, num_calls_ );
 
                return 0;
            }
 
            template < class TT >
            void call_ll_connect( ... )
            {
            }
 
            template < class TT >
            auto call_ll_disconnect( int ) -> decltype(&TT::ll_synchronized_callback_disconnect)
            {
                Obj.ll_synchronized_callback_disconnect( connection_value_ );
                return 0;
            }
 
            template < class TT >
            void call_ll_disconnect( ... )
            {
            }
 
            template < class TT >
            auto call_ll_update(
                bluetoe::link_layer::delta_time connection_interval ) -> decltype(&TT::ll_synchronized_callback_period_update)
            {
                Obj.ll_synchronized_callback_period_update( connection_interval, num_calls_, connection_value_ );
 
                return 0;
            }
 
            template < class TT >
            void call_ll_update( ... )
            {
            }
 
            void setup_timer( delta_time dt )
            {
                const bool setup = link_layer().schedule_synchronized_user_timer( dt, delta_time( MaximumExecutionTimeUS ) );
                static_cast< void >( setup );
                assert( setup );
            }
 
            LinkLayer& link_layer()
            {
                return *static_cast< LinkLayer* >( this );
            }
 
            void calculate_effective_period( delta_time connection_interval )
            {
                const auto interval_us = connection_interval.usec();
 
                if ( interval_us > MaximumPeriodUS )
                {
                    num_calls_         = ( interval_us + MaximumPeriodUS - 1 ) / MaximumPeriodUS;
                    num_intervals_     = 0;
                    effective_period_  = delta_time( interval_us / num_calls_ );
                }
                else
                {
                    num_calls_        = 0;
                    num_intervals_    = MaximumPeriodUS / interval_us;
                    effective_period_ = delta_time( num_intervals_ * interval_us );
                }
 
                num_intervals_since_anchor_moved_ = 0;
 
                assert( effective_period_.usec() <= MaximumPeriodUS );
            }
 
            delta_time first_timeout() const
            {
                return PhaseShiftUS < 0
                    ? effective_period_ - delta_time::usec( -PhaseShiftUS )
                    : effective_period_ + delta_time::usec( PhaseShiftUS );
            }
 
            delta_time effective_period_;
 
            unsigned instance_;
            unsigned latency_;
 
            // > 1 if there are more than 1 call to the CB at each interval
            unsigned num_calls_;
 
            // > 1 if there are more that 1 interval between two CB calls
            unsigned num_intervals_;
 
            unsigned num_intervals_since_anchor_moved_;
 
            typename T::connection connection_value_;
 
            volatile bool stopped_;
            volatile bool force_;
        };
 
        typedef details::synchronized_connection_event_callback_meta_type meta_type;
    };
 
    struct no_synchronized_connection_event_callback
    {
        template < typename LinkLayer >
        struct impl {
            void synchronized_connection_event_callback_new_connection( delta_time )
            {
            }
 
            void synchronized_connection_event_callback_start_changing_connection()
            {
            }
 
            void synchronized_connection_event_callback_connection_changed( delta_time )
            {
            }
 
            void synchronized_connection_event_callback_timeout( bool )
            {
            }
 
            void synchronized_connection_event_callback_disconnect()
            {
            }
        };
 
        typedef details::synchronized_connection_event_callback_meta_type meta_type;
    };
 
    template < unsigned ExpectedMinimumInterval_US >
    struct ranged_check_synchronized_connection_event_callback
    {
        template < typename Radio >
        static void check( const no_synchronized_connection_event_callback& )
        {
        }
 
        template < typename Radio, typename T, T& Obj, unsigned MaximumPeriodUS, int PhaseShiftUS, unsigned MaximumExecutionTimeUS >
        static void check( const synchronized_connection_event_callback< T, Obj, MaximumPeriodUS, PhaseShiftUS, MaximumExecutionTimeUS >& )
        {
            static_assert( MaximumPeriodUS <= ExpectedMinimumInterval_US,
                "To guaranty the timely execution of the callback, the MaximumPeriodUS must be small or equal to the minimum connection interval!" );
 
            static_assert( PhaseShiftUS < 0,
                "In order to make sure, that the callback is finished when the connection event starts, the callback must start prior to the connection event!" );
 
            static_assert( -PhaseShiftUS >= Radio::connection_event_setup_time_us,
                "PhaseShiftUS must start before the radios setup time." );
 
            static_assert( -PhaseShiftUS >= Radio::connection_event_setup_time_us + MaximumExecutionTimeUS,
                "Callback execution must end before setup time of the configured radio." );
 
            static_assert( MaximumPeriodUS / 2 >= MaximumExecutionTimeUS,
                "In worst case, the effective period of the callback invocation is half the requested period and thus must still be large enough for the expected runtimer of the callback." );
 
            static_assert( -PhaseShiftUS < MaximumPeriodUS / 2,
                "In worst case, the effective period of the callback invocation is half the requested period and thus must still be small than the phase shift." );
        }
 
        using meta_type = details::check_synchronized_connection_event_callback_meta_type;
    };
 
    using check_synchronized_connection_event_callback =
        ranged_check_synchronized_connection_event_callback< 7500u >;
 
    struct no_check_synchronized_connection_event_callback
    {
        template < typename Radio, class CBs >
        static void check( const CBs& )
        {
        }
 
        using meta_type = details::check_synchronized_connection_event_callback_meta_type;
    };
 
}
}
#endif