sockcanpp::CanDriver Class Reference

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

#include <CanDriver.hpp>

Collaboration diagram for sockcanpp::CanDriver:

Public Member Functions
	CanDriver (const string canInterface, const int32_t canProtocol, const CanId defaultSenderId=0)
	!< A separate CAN protocol, used by certain embedded device OEMs. More...
	CanDriver (const string canInterface, const int32_t canProtocol, const int32_t filterMask, const CanId defaultSenderId=0)
	!< Constructor More...
	CanDriver ()
virtual	~CanDriver ()
CanDriver &	setDefaultSenderId (const CanId id)
	!< Destructor More...
const CanId	getDefaultSenderId () const
	!< Sets the default sender ID More...
const int32_t	getFilterMask () const
	!< Gets the default sender ID More...
const int32_t	getMessageQueueSize () const
	!< Gets the filter mask used by this instance More...
const int32_t	getSocketFd () const
	!< Gets the amount of CAN messages found after last calling waitForMessages() More...
virtual bool	waitForMessages (milliseconds timeout=milliseconds(3000))
	!< The socket file descriptor used by this instance. More...
virtual CanMessage	readMessage ()
	!< Waits for CAN messages to appear More...
virtual int32_t	sendMessage (const CanMessage message, bool forceExtended=false)
	!< Attempts to read a single message from the bus More...
virtual int32_t	sendMessageQueue (queue< CanMessage > messages, milliseconds delay=milliseconds(20), bool forceExtended=false)
	!< Attempts to send a single CAN message More...
virtual queue< CanMessage >	readQueuedMessages ()
	!< Attempts to send a queue of messages More...
virtual void	setCanFilterMask (const int32_t mask)
	!< Attempts to read all queued messages from the bus More...

Static Public Attributes
static const int32_t	CAN_MAX_DATA_LENGTH = 8
static const int32_t	CAN_SOCK_RAW = CAN_RAW
	!< The maximum amount of bytes allowed in a single CAN frame More...
static const int32_t	CAN_SOCK_SEVEN = 7
	!< The raw CAN protocol More...

Protected Member Functions
virtual void	initialiseSocketCan ()
	!< Attempts to set a new CAN filter mask to the BIOS More...
virtual void	uninitialiseSocketCan ()
	!< Initialises socketcan More...

Private Member Functions
virtual CanMessage	readMessageLock (bool const lock=true)
	!< Uninitialises socketcan More...

Private Attributes
CanId	_defaultSenderId
	!< readMessage deadlock guard More...
int32_t	_canFilterMask
	!< The ID to send messages with if no other ID was set. More...
int32_t	_canProtocol
	!< The bit mask used to filter CAN messages More...
int32_t	_socketFd
	!< The protocol used when communicating via CAN More...
int32_t	_queueSize
	!< The CAN socket file descriptor More...
mutex	_lock
	!< Mutex for thread-safety. More...
mutex	_lockSend
string	_canInterface

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 62 of file CanDriver.hpp.

Constructor & Destructor Documentation

CanDriver() [1/3]

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

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

Definition at line 81 of file CanDriver.cpp.

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

References CanDriver().

CanDriver() [2/3]

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

!< Constructor

Definition at line 84 of file CanDriver.cpp.

                                                                                                                                   :
        _defaultSenderId(defaultSenderId), _canProtocol(canProtocol), _canInterface(canInterface), _canFilterMask(filterMask), _socketFd(-1) {
        initialiseSocketCan();
    }

References _canFilterMask, _canInterface, _canProtocol, _defaultSenderId, _socketFd, sockcanpp::CanId::CanId(), and initialiseSocketCan().

Referenced by CanDriver().

CanDriver() [3/3]

sockcanpp::CanDriver::CanDriver ( )

inline

Definition at line 71 of file CanDriver.hpp.

{}

~CanDriver()

virtual sockcanpp::CanDriver::~CanDriver ( )

inlinevirtual

Definition at line 72 of file CanDriver.hpp.

{ uninitialiseSocketCan(); } 

References uninitialiseSocketCan().

Member Function Documentation

getDefaultSenderId()

const CanId sockcanpp::CanDriver::getDefaultSenderId ( ) const

inline

!< Sets the default sender ID

Definition at line 77 of file CanDriver.hpp.

{ return this->_defaultSenderId; } 

References _defaultSenderId.

getFilterMask()

const int32_t sockcanpp::CanDriver::getFilterMask ( ) const

inline

!< Gets the default sender ID

Definition at line 79 of file CanDriver.hpp.

{ return this->_canFilterMask; } 

References _canFilterMask.

getMessageQueueSize()

const int32_t sockcanpp::CanDriver::getMessageQueueSize ( ) const

inline

!< Gets the filter mask used by this instance

Definition at line 80 of file CanDriver.hpp.

{ return this->_queueSize; } 

References _queueSize.

getSocketFd()

const int32_t sockcanpp::CanDriver::getSocketFd ( ) const

inline

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

Definition at line 81 of file CanDriver.hpp.

{ return this->_socketFd; } 

References _socketFd.

initialiseSocketCan()

void sockcanpp::CanDriver::initialiseSocketCan ( )

protectedvirtual

!< Attempts to set a new CAN filter mask to the BIOS

Initialises the underlying CAN socket.

Definition at line 243 of file CanDriver.cpp.

                                        {
        // unique_lock<mutex> locky(_lock);
 
        struct sockaddr_can address;
        struct ifreq ifaceRequest;
        int64_t fdOptions = 0;
        int32_t tmpReturn;
 
        memset(&address, 0, sizeof(sizeof(struct sockaddr_can)));
        memset(&ifaceRequest, 0, sizeof(sizeof(struct ifreq)));
 
        _socketFd = socket(PF_CAN, SOCK_RAW, _canProtocol);
 
        if (_socketFd == -1) {
            throw CanInitException(formatString("FAILED to initialise socketcan! Error: %d => %s", errno, strerror(errno)));
        }
 
        strcpy(ifaceRequest.ifr_name, _canInterface.c_str());
 
        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;
 
        setCanFilterMask(_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 setCanFilterMask().

Referenced by CanDriver().

readMessage()

CanMessage sockcanpp::CanDriver::readMessage ( )

virtual

!< Waits for CAN messages to appear

Attempts to read a message from the associated CAN bus.

Returns

CanMessage The message read from the bus.

Definition at line 121 of file CanDriver.cpp.

                                      {
    return readMessageLock();
    }

References readMessageLock().

readMessageLock()

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

privatevirtual

!< Uninitialises socketcan

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

Returns

CanMessage The message read from the bus.

Definition at line 130 of file CanDriver.cpp.

                                                         {
    std::unique_ptr<std::unique_lock<std::mutex>> _lockLck{nullptr};
    if (lock)
        _lockLck = std::unique_ptr<std::unique_lock<std::mutex>>{new std::unique_lock<std::mutex>{_lock}};
        if (0 > _socketFd)
        throw InvalidSocketException("Invalid socket!", _socketFd);
        int32_t readBytes{0};
        can_frame canFrame;
        memset(&canFrame, 0, sizeof(can_frame));
        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 send a queue of messages

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 202 of file CanDriver.cpp.

                                                    {
        if (_socketFd < 0)
        throw InvalidSocketException("Invalid socket!", _socketFd);
        unique_lock<mutex> locky(_lock);
        queue<CanMessage> messages;
        for (int32_t i = _queueSize; 0 < i; --i)
        messages.emplace(readMessageLock(false));
        return messages;
    }

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

sendMessage()

int32_t sockcanpp::CanDriver::sendMessage ( const CanMessage  message, bool  forceExtended = false  )

virtual

!< Attempts to read a single message from the bus

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

int32_t The amount of bytes sent on the bus.

Definition at line 153 of file CanDriver.cpp.

                                                                               {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky(_lockSend);
 
        int32_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()

int32_t sockcanpp::CanDriver::sendMessageQueue ( queue< CanMessage >  messages, milliseconds  delay = milliseconds(20), bool  forceExtended = false  )

virtual

!< Attempts to send a single CAN message

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 184 of file CanDriver.cpp.

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

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

setCanFilterMask()

void sockcanpp::CanDriver::setCanFilterMask ( const int32_t  mask )

virtual

!< Attempts to read all queued messages from the bus

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

Parameters

mask	The bit mask to apply.

Definition at line 217 of file CanDriver.cpp.

                                                       {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky(_lock);
        can_filter canFilter;
 
        canFilter.can_id   = _defaultSenderId;
        canFilter.can_mask = mask;
 
        if (setsockopt(_socketFd, SOL_CAN_RAW, CAN_RAW_FILTER, &canFilter, sizeof(canFilter)) == -1) {
            throw CanInitException(formatString("FAILED to set CAN filter mask %x on socket %d! Error: %d => %s", mask, _socketFd, errno, strerror(errno)));
        }
 
        _canFilterMask = mask;
    }

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

Referenced by initialiseSocketCan().

setDefaultSenderId()

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

inline

!< Destructor

Definition at line 75 of file CanDriver.hpp.

{ this->_defaultSenderId = id; return *this; } 

References _defaultSenderId.

uninitialiseSocketCan()

void sockcanpp::CanDriver::uninitialiseSocketCan ( )

protectedvirtual

!< Initialises socketcan

Closes the underlying CAN socket.

Definition at line 284 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()

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

virtual

!< The socket file descriptor used by this instance.

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 99 of file CanDriver.cpp.

                                                        {
        if (_socketFd < 0) { throw InvalidSocketException("Invalid socket!", _socketFd); }
 
        unique_lock<mutex> locky(_lock);
 
        fd_set readFileDescriptors;
        timeval waitTime;
        waitTime.tv_sec = timeout.count() / 1000;
        waitTime.tv_usec = timeout.count() * 1000;
 
        FD_ZERO(&readFileDescriptors);
        FD_SET(_socketFd, &readFileDescriptors);
        _queueSize = select(_socketFd + 1, &readFileDescriptors, 0, 0, &waitTime);
 
        return _queueSize > 0;
    }

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

Field Documentation

_canFilterMask

int32_t sockcanpp::CanDriver::_canFilterMask

private

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

Definition at line 104 of file CanDriver.hpp.

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

_canInterface

string sockcanpp::CanDriver::_canInterface

private

Definition at line 113 of file CanDriver.hpp.

Referenced by CanDriver(), and initialiseSocketCan().

_canProtocol

int32_t sockcanpp::CanDriver::_canProtocol

private

!< The bit mask used to filter CAN messages

Definition at line 105 of file CanDriver.hpp.

Referenced by CanDriver(), and initialiseSocketCan().

_defaultSenderId

CanId sockcanpp::CanDriver::_defaultSenderId

private

!< readMessage deadlock guard

Definition at line 102 of file CanDriver.hpp.

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

_lock

mutex sockcanpp::CanDriver::_lock

private

!< Mutex for thread-safety.

Definition at line 110 of file CanDriver.hpp.

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

_lockSend

mutex sockcanpp::CanDriver::_lockSend

private

Definition at line 111 of file CanDriver.hpp.

Referenced by sendMessage().

_queueSize

int32_t sockcanpp::CanDriver::_queueSize

private

!< The CAN socket file descriptor

Definition at line 107 of file CanDriver.hpp.

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

_socketFd

int32_t sockcanpp::CanDriver::_socketFd

private

!< The protocol used when communicating via CAN

Definition at line 106 of file CanDriver.hpp.

Referenced by CanDriver(), getSocketFd(), initialiseSocketCan(), readMessageLock(), readQueuedMessages(), sendMessage(), sendMessageQueue(), setCanFilterMask(), uninitialiseSocketCan(), and waitForMessages().

CAN_MAX_DATA_LENGTH

const int32_t sockcanpp::CanDriver::CAN_MAX_DATA_LENGTH = 8

static

Definition at line 64 of file CanDriver.hpp.

Referenced by sendMessage().

CAN_SOCK_RAW

const int32_t sockcanpp::CanDriver::CAN_SOCK_RAW = CAN_RAW

static

!< The maximum amount of bytes allowed in a single CAN frame

Definition at line 65 of file CanDriver.hpp.

CAN_SOCK_SEVEN

const int32_t sockcanpp::CanDriver::CAN_SOCK_SEVEN = 7

static

!< The raw CAN protocol

Definition at line 66 of file CanDriver.hpp.

---

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

• include/CanDriver.hpp
• src/CanDriver.cpp