can_network_manager.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
 
#ifndef CAN_NETWORK_MANAGER_HPP
#define CAN_NETWORK_MANAGER_HPP
 
#include "isobus/isobus/can_address_claim_state_machine.hpp"
#include "isobus/isobus/can_badge.hpp"
#include "isobus/isobus/can_callbacks.hpp"
#include "isobus/isobus/can_constants.hpp"
#include "isobus/isobus/can_extended_transport_protocol.hpp"
#include "isobus/isobus/can_identifier.hpp"
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/can_message.hpp"
#include "isobus/isobus/can_message_frame.hpp"
#include "isobus/isobus/can_network_configuration.hpp"
#include "isobus/isobus/can_transport_protocol.hpp"
#include "isobus/isobus/isobus_heartbeat.hpp"
#include "isobus/isobus/nmea2000_fast_packet_protocol.hpp"
#include "isobus/utility/event_dispatcher.hpp"
#include "isobus/utility/thread_synchronization.hpp"
 
#include <array>
#include <deque>
#include <list>
#include <memory>
#include <queue>
 
namespace isobus
{
    class PartneredControlFunction;
 
    //================================================================================================
    //================================================================================================
    class CANNetworkManager
    {
    public:
        static CANNetworkManager CANNetwork; 
 
        void initialize();
 
        std::shared_ptr<ControlFunction> get_control_function(std::uint8_t channelIndex, std::uint8_t address, CANLibBadge<AddressClaimStateMachine>) const;
 
        void add_global_parameter_group_number_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parent);
 
        void remove_global_parameter_group_number_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parent);
 
        std::size_t get_number_global_parameter_group_number_callbacks() const;
 
        void add_any_control_function_parameter_group_number_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parent);
 
        void remove_any_control_function_parameter_group_number_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parent);
 
        EventDispatcher<CANMessage> &get_transmitted_message_event_dispatcher();
 
        std::shared_ptr<InternalControlFunction> get_internal_control_function(std::shared_ptr<ControlFunction> controlFunction);
 
        float get_estimated_busload(std::uint8_t canChannel);
 
        bool send_can_message(std::uint32_t parameterGroupNumber,
                              const std::uint8_t *dataBuffer,
                              std::uint32_t dataLength,
                              std::shared_ptr<InternalControlFunction> sourceControlFunction,
                              std::shared_ptr<ControlFunction> destinationControlFunction = nullptr,
                              CANIdentifier::CANPriority priority = CANIdentifier::CANPriority::PriorityDefault6,
                              TransmitCompleteCallback txCompleteCallback = nullptr,
                              void *parentPointer = nullptr,
                              DataChunkCallback frameChunkCallback = nullptr);
 
        void update();
 
        void process_receive_can_message_frame(const CANMessageFrame &rxFrame);
 
        void process_transmitted_can_message_frame(const CANMessageFrame &txFrame);
 
        void on_control_function_destroyed(std::shared_ptr<ControlFunction> controlFunction, CANLibBadge<ControlFunction>);
 
        void on_control_function_created(std::shared_ptr<ControlFunction> controlFunction, CANLibBadge<ControlFunction>);
 
        void on_control_function_created(std::shared_ptr<ControlFunction> controlFunction, CANLibBadge<InternalControlFunction>);
 
        void on_control_function_created(std::shared_ptr<ControlFunction> controlFunction, CANLibBadge<PartneredControlFunction>);
 
        void add_control_function_status_change_callback(ControlFunctionStateCallback callback);
 
        void remove_control_function_status_change_callback(ControlFunctionStateCallback callback);
 
        const std::list<std::shared_ptr<InternalControlFunction>> &get_internal_control_functions() const;
 
        const std::list<std::shared_ptr<PartneredControlFunction>> &get_partnered_control_functions() const;
 
        std::list<std::shared_ptr<ControlFunction>> get_control_functions(bool includingOffline) const;
 
        std::list<std::shared_ptr<TransportProtocolSessionBase>> get_active_transport_protocol_sessions(std::uint8_t canPortIndex) const;
 
        std::unique_ptr<FastPacketProtocol> &get_fast_packet_protocol(std::uint8_t canPortIndex);
 
        HeartbeatInterface &get_heartbeat_interface(std::uint8_t canPortIndex);
 
        CANNetworkConfiguration &get_configuration();
 
        EventDispatcher<std::shared_ptr<InternalControlFunction>> &get_address_violation_event_dispatcher();
 
    protected:
        // Using protected region to allow protocols use of special functions from the network manager
        friend class AddressClaimStateMachine; 
        friend class ExtendedTransportProtocolManager; 
        friend class TransportProtocolManager; 
        friend class DiagnosticProtocol; 
        friend class ParameterGroupNumberRequestProtocol; 
        friend class FastPacketProtocol; 
 
        bool add_protocol_parameter_group_number_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parentPointer);
 
        bool remove_protocol_parameter_group_number_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parentPointer);
 
        bool send_can_message_raw(std::uint32_t portIndex,
                                  std::uint8_t sourceAddress,
                                  std::uint8_t destAddress,
                                  std::uint32_t parameterGroupNumber,
                                  std::uint8_t priority,
                                  const void *data,
                                  std::uint32_t size,
                                  CANLibBadge<AddressClaimStateMachine>) const;
 
        void protocol_message_callback(const CANMessage &message);
 
    private:
        CANNetworkManager();
 
        void update_address_table(const CANMessage &message);
 
        void update_internal_cfs();
 
        void update_busload(std::uint8_t channelIndex, std::uint32_t numberOfBitsProcessed);
 
        void update_busload_history();
 
        void update_control_functions(const CANMessageFrame &rxFrame);
 
        void update_new_partners();
 
        CANMessageFrame construct_frame(std::uint32_t portIndex,
                                        std::uint8_t sourceAddress,
                                        std::uint8_t destAddress,
                                        std::uint32_t parameterGroupNumber,
                                        std::uint8_t priority,
                                        const void *data,
                                        std::uint32_t size) const;
 
        std::shared_ptr<ControlFunction> get_control_function(std::uint8_t channelIndex, std::uint8_t address) const;
 
        CANMessage get_next_can_message_from_rx_queue();
 
        CANMessage get_next_can_message_from_tx_queue();
 
        void on_control_function_created(std::shared_ptr<ControlFunction> controlFunction);
 
        void process_any_control_function_pgn_callbacks(const CANMessage &currentMessage);
 
        void process_can_message_for_address_violations(const CANMessage &currentMessage);
 
        void process_control_function_state_change_callback(std::shared_ptr<ControlFunction> controlFunction, ControlFunctionState state);
 
        void process_protocol_pgn_callbacks(const CANMessage &currentMessage);
 
        void process_can_message_for_global_and_partner_callbacks(const CANMessage &message);
 
        void process_can_message_for_commanded_address(const CANMessage &message);
 
        void process_rx_messages();
 
        void process_tx_messages();
 
        void prune_inactive_control_functions();
 
        bool send_can_message_raw(std::uint32_t portIndex,
                                  std::uint8_t sourceAddress,
                                  std::uint8_t destAddress,
                                  std::uint32_t parameterGroupNumber,
                                  std::uint8_t priority,
                                  const void *data,
                                  std::uint32_t size) const;
 
        ParameterGroupNumberCallbackData get_global_parameter_group_number_callback(std::uint32_t index) const;
 
        static constexpr std::uint32_t BUSLOAD_SAMPLE_WINDOW_MS = 1000; 
        static constexpr std::uint32_t BUSLOAD_UPDATE_FREQUENCY_MS = 100; 
 
        CANNetworkConfiguration configuration; 
        std::array<std::unique_ptr<TransportProtocolManager>, CAN_PORT_MAXIMUM> transportProtocols; 
        std::array<std::unique_ptr<ExtendedTransportProtocolManager>, CAN_PORT_MAXIMUM> extendedTransportProtocols; 
        std::array<std::unique_ptr<FastPacketProtocol>, CAN_PORT_MAXIMUM> fastPacketProtocol; 
        std::array<std::unique_ptr<HeartbeatInterface>, CAN_PORT_MAXIMUM> heartBeatInterfaces; 
 
        std::array<std::deque<std::uint32_t>, CAN_PORT_MAXIMUM> busloadMessageBitsHistory; 
        std::array<std::uint32_t, CAN_PORT_MAXIMUM> currentBusloadBitAccumulator; 
        std::array<std::uint32_t, CAN_PORT_MAXIMUM> lastAddressClaimRequestTimestamp_ms; 
 
        std::array<std::array<std::shared_ptr<ControlFunction>, NULL_CAN_ADDRESS>, CAN_PORT_MAXIMUM> controlFunctionTable; 
        std::list<std::shared_ptr<ControlFunction>> inactiveControlFunctions; 
        std::list<std::shared_ptr<InternalControlFunction>> internalControlFunctions; 
        std::list<std::shared_ptr<PartneredControlFunction>> partneredControlFunctions; 
 
        std::list<ParameterGroupNumberCallbackData> protocolPGNCallbacks; 
        std::queue<CANMessage> receivedMessageQueue; 
        std::queue<CANMessage> transmittedMessageQueue; 
        std::list<ControlFunctionStateCallback> controlFunctionStateCallbacks; 
        std::vector<ParameterGroupNumberCallbackData> globalParameterGroupNumberCallbacks; 
        std::vector<ParameterGroupNumberCallbackData> anyControlFunctionParameterGroupNumberCallbacks; 
        EventDispatcher<CANMessage> messageTransmittedEventDispatcher; 
        EventDispatcher<std::shared_ptr<InternalControlFunction>> addressViolationEventDispatcher; 
        Mutex receivedMessageQueueMutex; 
        Mutex protocolPGNCallbacksMutex; 
        Mutex anyControlFunctionCallbacksMutex; 
        Mutex busloadUpdateMutex; 
        Mutex controlFunctionStatusCallbacksMutex; 
        Mutex transmittedMessageQueueMutex; 
        std::uint32_t busloadUpdateTimestamp_ms = 0; 
        std::uint32_t updateTimestamp_ms = 0; 
        bool initialized = false; 
    };
 
} // namespace isobus
 
#endif // CAN_NETWORK_MANAGER_HPP