isobus_heartbeat.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_HEARTBEAT_HPP
#define ISOBUS_HEARTBEAT_HPP
 
#include "isobus/isobus/can_callbacks.hpp"
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/can_message.hpp"
#include "isobus/utility/event_dispatcher.hpp"
 
#include <list>
 
namespace isobus
{
    class HeartbeatInterface
    {
    public:
        enum class HeartBeatError
        {
            InvalidSequenceCounter, 
            TimedOut 
        };
 
        HeartbeatInterface(const CANMessageFrameCallback &sendCANFrameCallback);
 
        void set_enabled(bool enable);
 
        bool is_enabled() const;
 
        bool request_heartbeat(std::shared_ptr<InternalControlFunction> sourceControlFunction,
                               std::shared_ptr<ControlFunction> destinationControlFunction) const;
 
        void on_new_internal_control_function(std::shared_ptr<InternalControlFunction> newControlFunction);
 
        void on_destroyed_internal_control_function(std::shared_ptr<InternalControlFunction> destroyedControlFunction);
 
        EventDispatcher<HeartBeatError, std::shared_ptr<ControlFunction>> &get_heartbeat_error_event_dispatcher();
 
        EventDispatcher<std::shared_ptr<ControlFunction>> &get_new_tracked_heartbeat_event_dispatcher();
 
        void process_rx_message(const CANMessage &message);
 
        void update();
 
    private:
        enum class SequenceCounterSpecialValue : std::uint8_t
        {
            Initial = 251, 
            Error = 254, 
            NotAvailable = 255 
        };
 
        static constexpr std::uint32_t SEQUENCE_TIMEOUT_MS = 300; 
        static constexpr std::uint32_t SEQUENCE_INITIAL_RESPONSE_TIMEOUT_MS = 250; 
        static constexpr std::uint32_t SEQUENCE_REPETITION_RATE_MS = 100; 
 
        class Heartbeat
        {
        public:
            explicit Heartbeat(std::shared_ptr<ControlFunction> sendingControlFunction);
 
            bool send(const HeartbeatInterface &parent);
 
            std::shared_ptr<ControlFunction> controlFunction; 
            std::uint32_t timestamp_ms; 
            std::uint32_t repetitionRate_ms = SEQUENCE_REPETITION_RATE_MS; 
            std::uint8_t sequenceCounter = static_cast<std::uint8_t>(SequenceCounterSpecialValue::Initial); 
        };
 
        static bool process_request_for_heartbeat(std::uint32_t parameterGroupNumber,
                                                  std::shared_ptr<ControlFunction> requestingControlFunction,
                                                  std::shared_ptr<ControlFunction> targetControlFunction,
                                                  std::uint32_t repetitionRate,
                                                  void *parentPointer);
 
        const CANMessageFrameCallback sendCANFrameCallback; 
        EventDispatcher<HeartBeatError, std::shared_ptr<ControlFunction>> heartbeatErrorEventDispatcher; 
        EventDispatcher<std::shared_ptr<ControlFunction>> newTrackedHeartbeatEventDispatcher; 
        std::list<Heartbeat> trackedHeartbeats; 
        bool enabled = true; 
    };
} // namespace isobus
 
#endif