LomCommunicationController.hpp

Go to the documentation of this file.

#ifndef IV_SRC_COMMS_CAN_LOMCOMMUNICATIONCONTROLLER_HPP_
#define IV_SRC_COMMS_CAN_LOMCOMMUNICATIONCONTROLLER_HPP_
 
#include "channels/AbstractChannel.hpp"
#include "comms/ICommunicationController.hpp"
#include "comms/can/CMessageCan.hpp"
#include "comms/can/ICanCommunicationProtocol.hpp"
#include "containers/CircularQueue.hpp"
 
namespace iv::comms::can
{
 
class AbstractMessageProcessor;
 
class LomCommunicationController final : public iv::comms::ICommunicationController,
                                         public std::enable_shared_from_this<LomCommunicationController>
{
    friend class LomCommunicationControllerFrame;
    friend class LomMessageProcessor;
 
public:
    LomCommunicationController() = delete;
 
    LomCommunicationController(const std::shared_ptr<ICommunicationDriver> &driver,
                               const std::shared_ptr<iv::model::comms::NetworkData> &networkData);
    LomCommunicationController(const LomCommunicationController &other) = delete;
    LomCommunicationController(const LomCommunicationController &&other) = delete;
    ~LomCommunicationController() override;
 
    LomCommunicationController &operator=(const LomCommunicationController &other) = delete;
    LomCommunicationController &operator=(LomCommunicationController &&other) = delete;
 
    void initialize() override;
    void addChannel(const std::shared_ptr<iv::channels::AbstractChannel> &channel) override;
 
    bool sendMessage(const std::shared_ptr<CMessageCan> &message) const;
    std::optional<std::shared_ptr<CMessageCan>> receiveMessage(iv::comms::can::eMessageType type,
                                                               std::optional<uint32_t> msgId = std::nullopt);
 
    void emptySdoQueue(iv::types::unitId unitId) const;
 
    std::mutex m_sendMutex;
    std::mutex m_receiveMutex;
    std::mutex m_processMutex;
 
private:
    bool frame() override;
    bool sendFrame();
    bool receiveFrame();
 
    std::shared_ptr<iv::comms::can::ICanCommunicationProtocol> m_canProtocol;
    std::map<std::pair<iv::types::unitId, iv::types::indexChannel>, std::weak_ptr<iv::channels::AbstractChannel>>
            m_lomChannels;
 
    std::unique_ptr<containers::CircularQueue<std::shared_ptr<CMessageCan>, 100>> m_sendQueue;
    std::map<iv::comms::can::eMessageType,
             std::unique_ptr<iv::containers::CircularQueue<std::shared_ptr<CMessageCan>, 500>>>
            m_receiveQueues;
    std::map<uint16_t, std::unique_ptr<iv::containers::CircularQueue<std::shared_ptr<CMessageCan>, 500>>>
            m_receivedSDOMessages;
    std::mutex m_receiveSdoMessagesMutex;
 
    std::shared_ptr<iv::comms::can::AbstractMessageProcessor> m_processor;
    iv::types::timestamp lastTimestampSync;
    iv::types::timestamp lastTimestampReceived;
 
    iv::comms::eLomLine m_line;
};
 
}// namespace iv::comms::can
 
#endif//IV_SRC_COMMS_CAN_LOMCOMMUNICATIONCONTROLLER_HPP_