CANConnector.h

 
#ifndef SIM_TO_DUT_INTERFACE_CANCONNECTOR_H
#define SIM_TO_DUT_INTERFACE_CANCONNECTOR_H
 
// Project includes
#include "../DuTConnector.h"
#include "InterfaceIndexIO.h"
#include "CANConnectorCodec.h"
#include "CANConnectorConfig.h"
#include "CANConnectorCodecFactory.h"
#include "../../Interface_Logger/InterfaceLogger.h"
 
// System includes
#include <thread>
#include <iostream>
#include <linux/can.h>
#include <linux/can/bcm.h>
#include <boost/asio.hpp>
#include <boost/make_shared.hpp>
#include <boost/system/error_code.hpp>
 
#define MAXFRAMES 256
 
struct bcmMsgSingleFrameCan {
    struct bcm_msg_head msg_head;
    struct can_frame canFrame[1];
};
 
struct bcmMsgSingleFrameCanFD {
    struct bcm_msg_head msg_head;
    struct canfd_frame canfdFrame[1];
};
 
struct bcmMsgMultipleFramesCan {
    struct bcm_msg_head msg_head;
    struct can_frame canFrames[MAXFRAMES];
};
 
struct bcmMsgMultipleFramesCanFD {
    struct bcm_msg_head msg_head;
    struct canfd_frame canfdFrames[MAXFRAMES];
};
 
namespace sim_interface::dut_connector::can {
 
    class CANConnector : public DuTConnector {
 
    public:
 
        CANConnector(std::shared_ptr<SharedQueue<SimEvent>> queueDuTToSim, const CANConnectorConfig &config);
 
        ~CANConnector();
 
        ConnectorInfo getConnectorInfo() override;
 
        void handleEventSingle(const SimEvent &event) override;
 
    private:
 
        boost::asio::generic::datagram_protocol::socket createBcmSocket(const CANConnectorConfig &canConfig);
 
        void startProcessing();
 
        void stopProcessing();
 
        void ioContextThreadFunction(const boost::shared_ptr<boost::asio::io_context> &context);
 
        void receiveOnSocket();
 
        void handleReceivedData(const bcm_msg_head *head, void *frames, uint32_t nframes, bool isCANFD);
 
        void handleRxChanged(const bcm_msg_head *head, void *frames, bool isCANFD);
 
        void txSendSingleFrame(struct canfd_frame frame, bool isCANFD);
 
        void txSendMultipleFrames(struct canfd_frame frames[], int nframes, bool isCANFD);
 
        void txSetupSingleFrame(struct canfd_frame frame, uint32_t count, struct bcm_timeval ival1,
                struct bcm_timeval ival2, bool isCANFD);
 
        void txSetupMultipleFrames(struct canfd_frame frames[], int nframes, uint32_t count[],
                struct bcm_timeval ival1[], struct bcm_timeval ival2[], bool isCANFD);
 
        void txSetupSequence(struct canfd_frame frames[], int nframes, uint32_t count, struct bcm_timeval ival1,
                             struct bcm_timeval ival2, bool isCANFD);
 
        void txSetupUpdateSingleFrame(struct canfd_frame frame, bool isCANFD, bool announce);
 
        void txSetupUpdateMultipleFrames(struct canfd_frame frames[], int nframes, bool isCANFD, bool announce);
 
        void txDelete(canid_t canID, bool isCANFD);
 
        void rxSetupCanID(canid_t canID, bool isCANFD);
 
        void rxSetupMask(canid_t canID, struct canfd_frame mask, bool isCANFD);
 
        void rxDelete(canid_t canID, bool isCANFD);
 
        static std::string convertCanIdToHex(canid_t canID);
 
        boost::shared_ptr<boost::asio::io_context> ioContext;                           
        boost::asio::generic::datagram_protocol::socket bcmSocket;                      
        std::array<std::uint8_t, sizeof(struct bcmMsgMultipleFramesCanFD)> rxBuffer{0}; 
        std::thread ioContextThread;                                                    
        CANConnectorConfig config;                                                      
        CANConnectorCodec *codec;                                                       
        std::map<std::string, bool> isSetup;                                            
    };
 
}
 
#endif //SIM_TO_DUT_INTERFACE_CANCONNECTOR_H