CanDriver class; handles communication via CAN. More...

#include <CanDriver.hpp>

Collaboration diagram for sockcanpp::CanDriver:

[legend]

Public Member Functions
	CanDriver (const string &canInterface, const int32_t canProtocol, const CanId defaultSenderId=0)
	Constructor.

	CanDriver (const string &canInterface, const int32_t canProtocol, const int32_t filterMask, const CanId defaultSenderId=0)

	CanDriver (const string &canInterface, const int32_t canProtocol, const filtermap_t &filters, const CanId defaultSenderId=0)

	CanDriver ()=default

virtual	~CanDriver ()
	Destructor.

CanDriver &	setDefaultSenderId (const CanId &id)
	Sets the default sender ID.

CanId	getDefaultSenderId () const
	Gets the default sender ID.

filtermap_t	getFilterMask () const
	Gets the filter mask used by this instance.

int32_t	getMessageQueueSize () const
	Gets the amount of CAN messages found after last calling waitForMessages()

int32_t	getSocketFd () const
	The socket file descriptor used by this instance.

string	getCanInterface () const
	The CAN interface used by this instance.

virtual bool	waitForMessages (microseconds timeout=3000us)
	Waits for CAN messages to appear.

virtual bool	waitForMessages (milliseconds timeout=3000ms)
	Waits for CAN messages to appear.

virtual bool	waitForMessages (nanoseconds timeout=3000ns)
	Waits for CAN messages to appear.

virtual CanMessage	readMessage ()
	Attempts to read a single message from the bus.

virtual ssize_t	sendMessage (const CanMessage &message, bool forceExtended=false)
	Attempts to send a single CAN message.

virtual ssize_t	sendMessageQueue (queue< CanMessage > &messages, microseconds delay=20us, bool forceExtended=false)
	Attempts to send a queue of messages.

virtual ssize_t	sendMessageQueue (queue< CanMessage > &messages, milliseconds delay=20ms, bool forceExtended=false)
	Attempts to send a queue of messages.

virtual ssize_t	sendMessageQueue (queue< CanMessage > &messages, nanoseconds delay=20ns, bool forceExtended=false)
	Attempts to send a queue of messages.

virtual queue< CanMessage >	readQueuedMessages ()
	Attempts to read all queued messages from the bus.

virtual void	allowCanFdFrames (const bool enabled=true) const
	Sets the CAN FD frame option for the interface.

virtual void	joinCanFilters () const
	Configures the socket to join the CAN filters.

virtual void	setCanFilterMask (const int32_t mask, const CanId &filterId)
	Attempts to set a new CAN filter mask to the interface.

virtual void	setCanFilters (const filtermap_t &filters)
	Sets the CAN filters for the interface.

virtual void	setErrorFilter (const bool enabled=true) const
	Sets the error filter for the interface.

virtual void	setReceiveOwnMessages (const bool enabled=true) const
	Sets the receive own messages option for the interface.

Static Public Attributes
static constexpr int32_t	CAN_MAX_DATA_LENGTH = 8
	The maximum amount of bytes allowed in a single CAN frame.

static constexpr int32_t	CAN_SOCK_RAW = CAN_RAW
	The raw CAN protocol.

static constexpr int32_t	CAN_SOCK_SEVEN = 7
	A separate CAN protocol, used by certain embedded device OEMs.

Protected Member Functions
virtual void	initialiseSocketCan ()
	Initialises socketcan.

virtual void	uninitialiseSocketCan ()
	Uninitialises socketcan.

Private Member Functions
virtual CanMessage	readMessageLock (bool const lock=true)
	readMessage deadlock guard

Private Attributes
CanId	_defaultSenderId
	The ID to send messages with if no other ID was set.

filtermap_t	_canFilterMask
	The bit mask used to filter CAN messages.

int32_t	_canProtocol
	The protocol used when communicating via CAN.

int32_t	_socketFd {-1}
	The CAN socket file descriptor.

int32_t	_queueSize {0}

bool	_canReadQueueSize {true}
	!< The size of the message queue read by waitForMessages()

mutex	_lock {}
	!< Is the queue size available

mutex	_lockSend {}

string	_canInterface
	The CAN interface used for communication (e.g. can0, can1, ...)

Detailed Description

CanDriver class; handles communication via CAN.

This class provides the means of easily communicating with other devices via CAN in C++.

Remarks: This class may be inherited by other applications and modified to suit your needs.

Definition at line 68 of file CanDriver.hpp.

Constructor & Destructor Documentation

◆ CanDriver() [1/4]

sockcanpp::CanDriver::CanDriver	(	const string &	canInterface,
		const int32_t	canProtocol,
		const CanId	defaultSenderId = `0`
	)

Constructor.

Definition at line 79 of file CanDriver.cpp.

79 :

80 CanDriver(canInterface, canProtocol, 0 /* match all */, defaultSenderId) { }

sockcanpp::CanDriver::CanDriver

CanDriver()=default

References CanDriver().

◆ CanDriver() [2/4]

sockcanpp::CanDriver::CanDriver	(	const string &	canInterface,
		const int32_t	canProtocol,
		const int32_t	filterMask,
		const CanId	defaultSenderId = `0`
	)

Definition at line 82 of file CanDriver.cpp.

82 :

83 CanDriver(canInterface, canProtocol, filtermap_t{{0, filterMask}}, defaultSenderId) { }

sockcanpp::filtermap_t

unordered_map< CanId, uint32_t, CanIdHasher > filtermap_t

Definition CanDriver.hpp:58

References CanDriver().

Referenced by CanDriver().

◆ CanDriver() [3/4]

sockcanpp::CanDriver::CanDriver	(	const string &	canInterface,
		const int32_t	canProtocol,
		const filtermap_t &	filters,
		const CanId	defaultSenderId = `0`
	)

Definition at line 85 of file CanDriver.cpp.

                                                                                                                                      :
        _defaultSenderId(defaultSenderId), _canFilterMask(filters), _canProtocol(canProtocol), _canInterface(canInterface) {
        initialiseSocketCan();
    }

References _canFilterMask, _canInterface, _canProtocol, _defaultSenderId, and initialiseSocketCan().

Referenced by CanDriver().

◆ CanDriver() [4/4]

sockcanpp::CanDriver::CanDriver ( )

default

◆ ~CanDriver()

virtual sockcanpp::CanDriver::~CanDriver ( )

inlinevirtual

Destructor.

Definition at line 79 of file CanDriver.hpp.

References uninitialiseSocketCan().

Member Function Documentation

◆ allowCanFdFrames()

void sockcanpp::CanDriver::allowCanFdFrames ( const bool enabled = true ) const

virtual

Sets the CAN FD frame option for the interface.

This option allows the current driver instance to receive CAN FD frames.

Parameters

enabled Whether or not to enable the CAN FD frame option.

Definition at line 297 of file CanDriver.cpp.

                                                              {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        int32_t canFdFrames = enabled ? 1 : 0;
 
        if (setsockopt(_socketFd, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canFdFrames, sizeof(canFdFrames)) == -1) {
            throw CanInitException(formatString("FAILED to set CAN FD frames on socket %d! Error: %d => %s", _socketFd, errno, strerror(errno)));
        }
    }

References _socketFd, sockcanpp::exceptions::CanInitException::CanInitException(), sockcanpp::formatString(), and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

◆ getCanInterface()

string sockcanpp::CanDriver::getCanInterface ( ) const

inline

The CAN interface used by this instance.

Definition at line 91 of file CanDriver.hpp.

References _canInterface.

◆ getDefaultSenderId()

CanId sockcanpp::CanDriver::getDefaultSenderId ( ) const

inline

Gets the default sender ID.

Definition at line 84 of file CanDriver.hpp.

References _defaultSenderId.

◆ getFilterMask()

filtermap_t sockcanpp::CanDriver::getFilterMask ( ) const

inline

Gets the filter mask used by this instance.

Definition at line 86 of file CanDriver.hpp.

References _canFilterMask.

◆ getMessageQueueSize()

int32_t sockcanpp::CanDriver::getMessageQueueSize ( ) const

inline

Gets the amount of CAN messages found after last calling waitForMessages()

Definition at line 88 of file CanDriver.hpp.

References _queueSize.

◆ getSocketFd()

int32_t sockcanpp::CanDriver::getSocketFd ( ) const

inline

The socket file descriptor used by this instance.

Definition at line 89 of file CanDriver.hpp.

References _socketFd.

◆ initialiseSocketCan()

void sockcanpp::CanDriver::initialiseSocketCan ( )

protectedvirtual

Initialises socketcan.

Initialises the underlying CAN socket.

Definition at line 420 of file CanDriver.cpp.

                                        {
        struct sockaddr_can address{};
        struct ifreq ifaceRequest{};
        int64_t fdOptions{0};
        int32_t tmpReturn{0};
 
        _socketFd = socket(PF_CAN, SOCK_RAW, _canProtocol);
 
        if (_socketFd == -1) {
            throw CanInitException(formatString("FAILED to initialise socketcan! Error: %d => %s", errno, strerror(errno)));
        }
 
        std::copy(_canInterface.begin(), _canInterface.end(), ifaceRequest.ifr_name);
 
        if ((tmpReturn = ioctl(_socketFd, SIOCGIFINDEX, &ifaceRequest)) == -1) {
            throw CanInitException(formatString("FAILED to perform IO control operation on socket %s! Error: %d => %s", _canInterface.c_str(), errno,
                                    strerror(errno)));
        }
 
        fdOptions = fcntl(_socketFd, F_GETFL);
        fdOptions |= O_NONBLOCK;
        tmpReturn = fcntl(_socketFd, F_SETFL, fdOptions);
 
        address.can_family = AF_CAN;
        address.can_ifindex = ifaceRequest.ifr_ifindex;
 
        setCanFilters(_canFilterMask);
 
        if ((tmpReturn = bind(_socketFd, (struct sockaddr*)&address, sizeof(address))) == -1) {
            throw CanInitException(formatString("FAILED to bind to socket CAN! Error: %d => %s", errno, strerror(errno)));
        }
    }

References _canFilterMask, _canInterface, _canProtocol, _socketFd, sockcanpp::exceptions::CanInitException::CanInitException(), sockcanpp::formatString(), and setCanFilters().

Referenced by CanDriver().

◆ joinCanFilters()

void sockcanpp::CanDriver::joinCanFilters ( ) const

virtual

Configures the socket to join the CAN filters.

Configures the socket to join the CAN filters. This is especially required, when using inverted CAN filters.

Source: https://stackoverflow.com/a/57680496/2921426

Definition at line 333 of file CanDriver.cpp.

                                         {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        int32_t joinFilters = 1;
 
        if (setsockopt(_socketFd, SOL_CAN_RAW, CAN_RAW_JOIN_FILTERS, &joinFilters, sizeof(joinFilters)) == -1) {
            throw CanInitException(formatString("FAILED to join CAN filters on socket %d! Error: %d => %s", _socketFd, errno, strerror(errno)));
        }
    }

References _socketFd, sockcanpp::exceptions::CanInitException::CanInitException(), sockcanpp::formatString(), and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

◆ readMessage()

CanMessage sockcanpp::CanDriver::readMessage ( )

virtual

Attempts to read a single message from the bus.

Attempts to read a message from the associated CAN bus.

Returns: CanMessage The message read from the bus.

Definition at line 151 of file CanDriver.cpp.

151{ return readMessageLock(); }

sockcanpp::CanDriver::readMessageLock

virtual CanMessage readMessageLock(bool const lock=true)

readMessage deadlock guard

Definition CanDriver.cpp:158

References readMessageLock().

◆ readMessageLock()

CanMessage sockcanpp::CanDriver::readMessageLock ( bool const lock = true )

privatevirtual

readMessage deadlock guard

readMessage deadlock guard, attempts to read a message from the associated CAN bus.

Returns: CanMessage The message read from the bus.

Definition at line 158 of file CanDriver.cpp.

                                                         {
        unique_ptr<unique_lock<mutex>> locky{nullptr};
 
        if (lock) { locky = unique_ptr<unique_lock<mutex>>{new unique_lock<mutex>{_lock}}; }
        
        if (0 > _socketFd) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        ssize_t readBytes{0};
        can_frame canFrame{};
 
        readBytes = read(_socketFd, &canFrame, sizeof(can_frame));
 
        if (0 > readBytes) { throw CanException(formatString("FAILED to read from CAN! Error: %d => %s", errno, strerror(errno)), _socketFd); }
 
        return CanMessage{canFrame};
    }

References _lock, _socketFd, sockcanpp::exceptions::CanException::CanException(), sockcanpp::CanMessage::CanMessage(), sockcanpp::formatString(), and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

Referenced by readMessage(), and readQueuedMessages().

◆ readQueuedMessages()

queue< CanMessage > sockcanpp::CanDriver::readQueuedMessages ( )

virtual

Attempts to read all queued messages from the bus.

Attempts to read all messages stored in the buffer for the associated CAN bus.

Returns: queue<CanMessage> A queue containing the messages read from the bus buffer.

Definition at line 258 of file CanDriver.cpp.

                                                    {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky{_lock};
        queue<CanMessage> messages{};
 
        if (_canReadQueueSize) {
            for (int32_t i = _queueSize; 0 < i; --i) {
                messages.emplace(readMessageLock(false));
            }
        } else {
            // If the interface doesn't support FIONREAD, fall back
            // to reading until data exhausted.
            bool more{true};
 
            do {
                ssize_t readBytes;
                can_frame canFrame{};
                readBytes = read(_socketFd, &canFrame, sizeof(can_frame));
                if (readBytes >= 0) {
                    messages.emplace(canFrame);
                } else if (errno == EAGAIN) {
                    more = false;
                } else {
                    throw CanException(formatString("FAILED to read from CAN! Error: %d => %s", errno, strerror(errno)), _socketFd);
                }
            } while (more);
        }
 
        return messages;
    }

References _canReadQueueSize, _lock, _queueSize, _socketFd, sockcanpp::exceptions::CanException::CanException(), sockcanpp::formatString(), sockcanpp::exceptions::InvalidSocketException::InvalidSocketException(), and readMessageLock().

◆ sendMessage()

ssize_t sockcanpp::CanDriver::sendMessage	(	const CanMessage &	message,
		bool	forceExtended = `false`
	)

virtual

Attempts to send a single CAN message.

Attempts to send a CAN message on the associated bus.

Parameters

message	The message to be sent.
forceExtended	Whether or not to force use of an extended ID.

Returns: ssize_t The amount of bytes sent on the bus.

Definition at line 183 of file CanDriver.cpp.

                                                                                {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky(_lockSend);
 
        ssize_t bytesWritten = 0;
 
        if (message.getFrameData().size() > CAN_MAX_DATA_LENGTH) {
            throw CanException(formatString("INVALID data length! Message must be smaller than %d bytes!", CAN_MAX_DATA_LENGTH), _socketFd);
        }
 
        auto canFrame = message.getRawFrame();
 
        if (forceExtended || ((uint32_t)message.getCanId() > CAN_SFF_MASK)) { canFrame.can_id |= CAN_EFF_FLAG; }
 
        bytesWritten = write(_socketFd, (const void*)&canFrame, sizeof(canFrame));
 
        if (bytesWritten == -1) { throw CanException(formatString("FAILED to write data to socket! Error: %d => %s", errno, strerror(errno)), _socketFd); }
 
        return bytesWritten;
    }

References _lockSend, _socketFd, CAN_MAX_DATA_LENGTH, sockcanpp::exceptions::CanException::CanException(), sockcanpp::formatString(), sockcanpp::CanMessage::getCanId(), sockcanpp::CanMessage::getFrameData(), sockcanpp::CanMessage::getRawFrame(), and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

Referenced by sendMessageQueue().

◆ sendMessageQueue() [1/3]

ssize_t sockcanpp::CanDriver::sendMessageQueue	(	queue< CanMessage > &	messages,
		microseconds	delay = `20us`,
		bool	forceExtended = `false`
	)

virtual

Attempts to send a queue of messages.

Attempts to send a queue of messages on the associated CAN bus.

Parameters

messages	A queue containing the messages to be sent.
delay	If greater than 0, will delay the sending of the next message.
forceExtended	Whether or not to force use of an extended ID.

Returns: int32_t The total amount of bytes sent.

Definition at line 214 of file CanDriver.cpp.

214{ return sendMessageQueue(messages, std::chrono::duration_cast<nanoseconds>(delay), forceExtended); }

sockcanpp::CanDriver::sendMessageQueue

virtual ssize_t sendMessageQueue(queue< CanMessage > &messages, microseconds delay=20us, bool forceExtended=false)

Attempts to send a queue of messages.

Definition CanDriver.cpp:214

References sendMessageQueue().

◆ sendMessageQueue() [2/3]

ssize_t sockcanpp::CanDriver::sendMessageQueue	(	queue< CanMessage > &	messages,
		milliseconds	delay = `20ms`,
		bool	forceExtended = `false`
	)

virtual

Attempts to send a queue of messages.

Attempts to send a queue of messages on the associated CAN bus.

Parameters

messages	A queue containing the messages to be sent.
delay	If greater than 0, will delay the sending of the next message.
forceExtended	Whether or not to force use of an extended ID.

Returns: int32_t The total amount of bytes sent.

Definition at line 225 of file CanDriver.cpp.

225{ return sendMessageQueue(messages, std::chrono::duration_cast<nanoseconds>(delay), forceExtended); }

References sendMessageQueue().

◆ sendMessageQueue() [3/3]

ssize_t sockcanpp::CanDriver::sendMessageQueue	(	queue< CanMessage > &	messages,
		nanoseconds	delay = `20ns`,
		bool	forceExtended = `false`
	)

virtual

Attempts to send a queue of messages.

Attempts to send a queue of messages on the associated CAN bus.

Parameters

messages	A queue containing the messages to be sent.
delay	If greater than 0, will delay the sending of the next message.
forceExtended	Whether or not to force use of an extended ID.

Returns: int32_t The total amount of bytes sent.

Definition at line 236 of file CanDriver.cpp.

                                                                                                          {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        ssize_t totalBytesWritten = 0;
 
        while (!messages.empty()) {
            totalBytesWritten += sendMessage(messages.front(), forceExtended);
            messages.pop();
 
            if (delay.count() > 0) {
                sleep_for(delay);
            }
        }
 
        return totalBytesWritten;
    }

References _socketFd, sockcanpp::exceptions::InvalidSocketException::InvalidSocketException(), and sendMessage().

Referenced by sendMessageQueue(), and sendMessageQueue().

◆ setCanFilterMask()

void sockcanpp::CanDriver::setCanFilterMask	(	const int32_t	mask,
		const CanId &	filterId
	)

virtual

Attempts to set a new CAN filter mask to the interface.

Attempts to set the filter mask for the associated CAN bus.

Parameters

mask	The bit mask to apply.
filterId	The ID to filter on.

Definition at line 349 of file CanDriver.cpp.

349{ setCanFilters({{filterId, static_cast<uint32_t>(mask)}}); }

References setCanFilters().

◆ setCanFilters()

void sockcanpp::CanDriver::setCanFilters ( const filtermap_t & filters )

virtual

Sets the CAN filters for the interface.

Sets multiple CAN filters for the associated CAN bus.

Parameters

filters A map containing the filters to apply.

Definition at line 356 of file CanDriver.cpp.

                                                            {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky(_lock);
        vector<can_filter> canFilters{};
 
        // Structured bindings only available with C++17
        #if __cplusplus >= 201703L
        for (const auto [id, filter] : filters) {
            canFilters.push_back({*id, filter});
        }
        #else
        for (const auto& filterPair : filters) {
            canFilters.push_back({*filterPair.first, filterPair.second});
        }
        #endif
 
        if (setsockopt(_socketFd, SOL_CAN_RAW, CAN_RAW_FILTER, canFilters.data(), canFilters.size() * sizeof(can_filter)) == -1) {
            throw CanInitException(formatString("FAILED to set CAN filters on socket %d! Error: %d => %s", _socketFd, errno, strerror(errno)));
        }
    }

References _lock, _socketFd, sockcanpp::exceptions::CanInitException::CanInitException(), sockcanpp::formatString(), sockcanpp::exceptions::InvalidSocketException::InvalidSocketException(), and sockcanpp::CanId::operator*().

Referenced by initialiseSocketCan(), and setCanFilterMask().

◆ setDefaultSenderId()

CanDriver & sockcanpp::CanDriver::setDefaultSenderId ( const CanId & id )

inline

Sets the default sender ID.

Definition at line 82 of file CanDriver.hpp.

References _defaultSenderId.

◆ setErrorFilter()

void sockcanpp::CanDriver::setErrorFilter ( const bool enabled = true ) const

virtual

Sets the error filter for the interface.

Sets the error filter for the associated CAN bus.

Parameters

enabled Whether or not to enable the error filter.

Definition at line 383 of file CanDriver.cpp.

                                                            {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        int32_t errorFilter = enabled ? 1 : 0;
 
        if (setsockopt(_socketFd, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &errorFilter, sizeof(errorFilter)) == -1) {
            throw CanInitException(formatString("FAILED to set CAN error filter on socket %d! Error: %d => %s", _socketFd, errno, strerror(errno)));
        }
    }

References _socketFd, sockcanpp::exceptions::CanInitException::CanInitException(), sockcanpp::formatString(), and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

◆ setReceiveOwnMessages()

void sockcanpp::CanDriver::setReceiveOwnMessages ( const bool enabled = true ) const

virtual

Sets the receive own messages option for the interface.

Sets the receive own messages option for the associated CAN bus.

This option allows the socket to receive its own messages.

Parameters

enabled Whether or not to enable the receive own messages option.

Definition at line 400 of file CanDriver.cpp.

                                                                  {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        int32_t receiveOwnMessages = enabled ? 1 : 0;
 
        if (setsockopt(_socketFd, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &receiveOwnMessages, sizeof(receiveOwnMessages)) == -1) {
            throw CanInitException(formatString("FAILED to set CAN error filter on socket %d! Error: %d => %s", _socketFd, errno, strerror(errno)));
        }
    }

References _socketFd, sockcanpp::exceptions::CanInitException::CanInitException(), sockcanpp::formatString(), and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

◆ uninitialiseSocketCan()

void sockcanpp::CanDriver::uninitialiseSocketCan ( )

protectedvirtual

Uninitialises socketcan.

Closes the underlying CAN socket.

Definition at line 456 of file CanDriver.cpp.

                                          {
        unique_lock<mutex> locky(_lock);
 
        if (_socketFd <= 0) { throw CanCloseException("Cannot close invalid socket!"); }
 
        if (close(_socketFd) == -1) { throw CanCloseException(formatString("FAILED to close CAN socket! Error: %d => %s", errno, strerror(errno))); }
 
        _socketFd = -1;
    }

References _lock, _socketFd, sockcanpp::exceptions::CanCloseException::CanCloseException(), and sockcanpp::formatString().

Referenced by ~CanDriver().

◆ waitForMessages() [1/3]

bool sockcanpp::CanDriver::waitForMessages ( microseconds timeout = 3000us )

virtual

Waits for CAN messages to appear.

Blocks until one or more CAN messages appear on the bus, or until the timeout runs out.

Parameters

timeout The time (in µsec) to wait before timing out.

Returns: true If messages are available on the bus.; false Otherwise.

Definition at line 100 of file CanDriver.cpp.

                                                         {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky(_lock);
 
        fd_set readFileDescriptors;
        timeval waitTime{0, static_cast<suseconds_t>(timeout.count())};
 
        FD_ZERO(&readFileDescriptors);
        FD_SET(_socketFd, &readFileDescriptors);
        const auto fdsAvailable = select(_socketFd + 1, &readFileDescriptors, nullptr, nullptr, &waitTime);
 
        int32_t bytesAvailable{0};
        const auto retCode = ioctl(_socketFd, FIONREAD, &bytesAvailable);
        if (retCode == 0) {
            _queueSize = static_cast<int32_t>(std::ceil(bytesAvailable / sizeof(can_frame)));
        } else {
            _queueSize = 0;
            // vcan interfaces don't support FIONREAD. So fall back to
            // using alternate implementation in readQueuedMessages().
            _canReadQueueSize = false;
        }
 
        return fdsAvailable > 0;
    }

References _canReadQueueSize, _lock, _queueSize, _socketFd, and sockcanpp::exceptions::InvalidSocketException::InvalidSocketException().

Referenced by waitForMessages(), and waitForMessages().

◆ waitForMessages() [2/3]

bool sockcanpp::CanDriver::waitForMessages ( milliseconds timeout = 3000ms )

virtual

Waits for CAN messages to appear.

Blocks until one or more CAN messages appear on the bus, or until the timeout runs out.

Parameters

timeout The time (in millis) to wait before timing out.

Returns: true If messages are available on the bus.; false Otherwise.

Definition at line 134 of file CanDriver.cpp.

134{ return waitForMessages(std::chrono::duration_cast<microseconds>(timeout)); }

sockcanpp::CanDriver::waitForMessages

virtual bool waitForMessages(microseconds timeout=3000us)

Waits for CAN messages to appear.

Definition CanDriver.cpp:100

References waitForMessages().

◆ waitForMessages() [3/3]

bool sockcanpp::CanDriver::waitForMessages ( nanoseconds timeout = 3000ns )

virtual

Waits for CAN messages to appear.

Blocks until one or more CAN messages appear on the bus, or until the timeout runs out.

Parameters

timeout The time (in nanoseconds) to wait before timing out.

Returns: true If messages are available on the bus.; false Otherwise.

Definition at line 144 of file CanDriver.cpp.

144{ return waitForMessages(std::chrono::duration_cast<microseconds>(timeout)); }

References waitForMessages().

Field Documentation

◆ _canFilterMask

filtermap_t sockcanpp::CanDriver::_canFilterMask

private

The bit mask used to filter CAN messages.

Definition at line 129 of file CanDriver.hpp.

Referenced by CanDriver(), getFilterMask(), and initialiseSocketCan().

◆ _canInterface

string sockcanpp::CanDriver::_canInterface

private

The CAN interface used for communication (e.g. can0, can1, ...)

Definition at line 140 of file CanDriver.hpp.

Referenced by CanDriver(), getCanInterface(), and initialiseSocketCan().

◆ _canProtocol

int32_t sockcanpp::CanDriver::_canProtocol

private

The protocol used when communicating via CAN.

Definition at line 131 of file CanDriver.hpp.

Referenced by CanDriver(), and initialiseSocketCan().

◆ _canReadQueueSize

bool sockcanpp::CanDriver::_canReadQueueSize {true}

private

!< The size of the message queue read by waitForMessages()

Definition at line 134 of file CanDriver.hpp.

134{true};

Referenced by readQueuedMessages(), and waitForMessages().

◆ _defaultSenderId

CanId sockcanpp::CanDriver::_defaultSenderId

private

The ID to send messages with if no other ID was set.

Definition at line 127 of file CanDriver.hpp.

Referenced by CanDriver(), getDefaultSenderId(), and setDefaultSenderId().

◆ _lock

mutex sockcanpp::CanDriver::_lock {}

private

!< Is the queue size available

< Mutex for thread-safety.

Definition at line 137 of file CanDriver.hpp.

137{};

Referenced by readMessageLock(), readQueuedMessages(), setCanFilters(), uninitialiseSocketCan(), and waitForMessages().

◆ _lockSend

mutex sockcanpp::CanDriver::_lockSend {}

private

Definition at line 138 of file CanDriver.hpp.

138{};

Referenced by sendMessage().

◆ _queueSize

int32_t sockcanpp::CanDriver::_queueSize {0}

private

Definition at line 133 of file CanDriver.hpp.

133{0};

Referenced by getMessageQueueSize(), readQueuedMessages(), and waitForMessages().

◆ _socketFd

int32_t sockcanpp::CanDriver::_socketFd {-1}

private

The CAN socket file descriptor.

Definition at line 132 of file CanDriver.hpp.

132{-1};

Referenced by allowCanFdFrames(), getSocketFd(), initialiseSocketCan(), joinCanFilters(), readMessageLock(), readQueuedMessages(), sendMessage(), sendMessageQueue(), setCanFilters(), setErrorFilter(), setReceiveOwnMessages(), uninitialiseSocketCan(), and waitForMessages().

◆ CAN_MAX_DATA_LENGTH

constexpr int32_t sockcanpp::CanDriver::CAN_MAX_DATA_LENGTH = 8

staticconstexpr

The maximum amount of bytes allowed in a single CAN frame.

Definition at line 70 of file CanDriver.hpp.

Referenced by sendMessage().

◆ CAN_SOCK_RAW

constexpr int32_t sockcanpp::CanDriver::CAN_SOCK_RAW = CAN_RAW

staticconstexpr

The raw CAN protocol.

Definition at line 71 of file CanDriver.hpp.

◆ CAN_SOCK_SEVEN

constexpr int32_t sockcanpp::CanDriver::CAN_SOCK_SEVEN = 7

staticconstexpr

A separate CAN protocol, used by certain embedded device OEMs.

Definition at line 72 of file CanDriver.hpp.

The documentation for this class was generated from the following files:

include/CanDriver.hpp
src/CanDriver.cpp

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CanDriver() [1/4]

◆ CanDriver() [2/4]

◆ CanDriver() [3/4]

◆ CanDriver() [4/4]

◆ ~CanDriver()

Member Function Documentation

◆ allowCanFdFrames()

◆ getCanInterface()

◆ getDefaultSenderId()

◆ getFilterMask()

◆ getMessageQueueSize()

◆ getSocketFd()

◆ initialiseSocketCan()

◆ joinCanFilters()

◆ readMessage()

◆ readMessageLock()

◆ readQueuedMessages()

◆ sendMessage()

◆ sendMessageQueue() [1/3]

◆ sendMessageQueue() [2/3]

◆ sendMessageQueue() [3/3]

◆ setCanFilterMask()

◆ setCanFilters()

◆ setDefaultSenderId()

◆ setErrorFilter()

◆ setReceiveOwnMessages()

◆ uninitialiseSocketCan()

◆ waitForMessages() [1/3]

◆ waitForMessages() [2/3]

◆ waitForMessages() [3/3]

Field Documentation

◆ _canFilterMask

◆ _canInterface

◆ _canProtocol

◆ _canReadQueueSize

◆ _defaultSenderId

◆ _lock

◆ _lockSend

◆ _queueSize

◆ _socketFd

◆ CAN_MAX_DATA_LENGTH

◆ CAN_SOCK_RAW

◆ CAN_SOCK_SEVEN