ISocketCANInterface.hpp

Go to the documentation of this file.

#ifndef IV_SRC_COMMS_PEAK_NETDEV_IPEAKINTERFACENETDEV_HPP_
#define IV_SRC_COMMS_PEAK_NETDEV_IPEAKINTERFACENETDEV_HPP_
 
#include "comms/can/CMessageCan.hpp"
#include "core/CStringTools.hpp"
#include "core/system.hpp"
#include "core/Timestamp.hpp"
#include "core/utils.hpp"
#include "model/comms/SocketCanSettings.hpp"
 
#include <cstdint>
#include <iostream>
 
namespace iv::comms::socketcan
{
 
const std::string PEAK_MODULE_NAME = "peak_usb";
const std::string IXXAT_MODULE_NAME = "ix_usb_can";
const std::string COMMAND_PEAK_MODULE_IS_LOADED = "lsmod | grep " + PEAK_MODULE_NAME;
const std::string COMMAND_PEAK_MODULE_LOAD = "sudo -n modprobe " + PEAK_MODULE_NAME;
const std::string COMMAND_IXXAT_MODULE_IS_LOADED = "lsmod | grep " + IXXAT_MODULE_NAME;
const std::string COMMAND_IXXAT_MODULE_LOAD = "sudo -n modprobe " + IXXAT_MODULE_NAME;
const std::string COMMAND_INTERFACE_EXISTS = "ip link show ";
const std::string COMMAND_INTERFACE_UP = "cat /sys/class/net/{}/operstate";
const std::string COMMAND_INTERFACE_SET = "sudo -n ip link set ";
const std::string COMMAND_INTERFACE_SET_BITRATE = "sudo -n ip link set {} type can bitrate {}";
 
class ISocketCANInterface
{
public:
    virtual ~ISocketCANInterface() = default;
 
    virtual void *ctrlOpen(const char *deviceId, iv::model::comms::socketcan::eBaudRate baudRate) = 0;
    virtual uint32_t ctrlInit(void *socket, iv::model::comms::socketcan::eBaudRate baudRate) = 0;
    virtual uint32_t ctrlReceive(void *socket, std::shared_ptr<CMessageCan> &pStcMessage) = 0;
    virtual uint32_t ctrlSend(void *socket, const CMessageCan &pStcMessage) = 0;
    virtual void ctrlClose(void *socket) = 0;
 
protected:
    static void prvPeakKernelModuleLoad()
    {
        if (iv::system::executeCommand(COMMAND_PEAK_MODULE_IS_LOADED).find(PEAK_MODULE_NAME) == std::string::npos)
        {
            if (not iv::system::executeCommand(COMMAND_PEAK_MODULE_LOAD).empty())
            {
                throw std::runtime_error("Cannot load kernel module " + PEAK_MODULE_NAME);
            }
        }
    }
 
    static void prvIxxatKernelModuleLoad()
    {
        if (iv::system::executeCommand(COMMAND_IXXAT_MODULE_IS_LOADED).find(IXXAT_MODULE_NAME) == std::string::npos)
        {
            if (not iv::system::executeCommand(COMMAND_IXXAT_MODULE_LOAD).empty())
            {
                throw std::runtime_error("Cannot load kernel module " + IXXAT_MODULE_NAME);
            }
        }
    }
 
    static bool prvExistsInterface(const std::string &deviceId)
    {
        return not iv::system::executeCommand(COMMAND_INTERFACE_EXISTS + " " + deviceId).empty();
    }
 
    static bool prvIsInterfaceUp(const std::string &deviceId)
    {
        static std::map<std::string, iv::types::timestamp> lastCheckedInterfaces {};
 
        iv::types::timestamp now = iv::time::Timestamp().inMilliseconds();
 
        if (not lastCheckedInterfaces.contains(deviceId) or iv::time::utils::safeAbsoluteDiff(lastCheckedInterfaces.at(deviceId), iv::time::Timestamp().inMilliseconds()) > 500)
        {
            bool result = iv::system::executeCommand(fmt::format(fmt::runtime(COMMAND_INTERFACE_UP), deviceId)).find("up") !=
               std::string::npos;
 
            if (not result)
            {
                lastCheckedInterfaces.erase(deviceId);
                return result;
            }
 
            lastCheckedInterfaces.insert_or_assign(deviceId, now);
        }
 
        return true;
 
    }
 
    static bool prvSetInterface(const std::string &deviceId, bool up)
    {
        std::string commandResult =
                iv::system::executeCommand(COMMAND_INTERFACE_SET + " " + deviceId + (up ? " up" : " down"));
 
        if (commandResult.find("Cannot find device") != std::string::npos)
        {
#ifndef NDEBUG
            std::cout << "Cannot find device " << deviceId
                      << ". Probably the device is not connected or the device id is wrong." << std::endl;
#endif
        }
        else if (commandResult.find("argument") != std::string::npos)
        {
#ifndef NDEBUG
            std::cout << "Cannot set interface " << deviceId << (up ? "up" : "down")
                      << ". Probably the device is not connected or the device id is wrong." << std::endl;
#endif
        }
        else
        {
            return true;
        }
 
        return false;
    }
 
    static bool prvSetBitrate(const std::string &deviceId, uint64_t btr0)
    {
        std::string commandResult =
                iv::system::executeCommand(fmt::format(fmt::runtime(COMMAND_INTERFACE_SET_BITRATE), deviceId, btr0));
 
        if (commandResult.find("Cannot find device") != std::string::npos)
        {
#ifndef NDEBUG
            std::cout << "Cannot find device " << deviceId
                      << ". Probably the device is not connected or the device id is wrong." << std::endl;
#endif
        }
        else if (commandResult.find("argument") != std::string::npos)
        {
#ifndef NDEBUG
            std::cout << "Cannot set bitrate " << btr0 << " for interface " << deviceId
                      << ". Probably the device is not connected or the device id is wrong." << std::endl;
#endif
        }
        else
        {
            return true;
        }
 
        return false;
    }
 
    std::string m_interfaceName {};
};
 
}// namespace iv::comms::socketcan
 
#endif//IV_SRC_COMMS_PEAK_NETDEV_IPEAKINTERFACENETDEV_HPP_