CanIf.cxx

Go to the documentation of this file.

 
#include "utils/CanIf.hxx"
 
Pool *CanFrameWriteFlow::pool()
{
    return ifCan_->device()->pool();
}
 
void CanFrameWriteFlow::send(Buffer<CanHubData> *message, unsigned priority)
{
    LOG(VERBOSE, "outgoing message %" PRIx32 ".",
        GET_CAN_FRAME_ID_EFF(message->data()->frame()));
    message->data()->skipMember_ = ifCan_->hub_port();
    ifCan_->device()->send(message, priority);
}
 
Pool *CanFrameReadFlow::pool()
{
    /* NOTE(balazs.racz) This pool should rather be the application-level
     * buffer pool (for example openlcb::AsyncIf::dispatcher()::pool(), but
     * that pointer is not available here. At the moment applications use the
     * mainBufferPool. */
    return ifCan_->frame_dispatcher()->pool();
}
 
void CanFrameReadFlow::send(Buffer<CanHubData> *message, unsigned priority)
{
    const struct can_frame &frame = message->data()->frame();
    if (IS_CAN_FRAME_ERR(frame) || IS_CAN_FRAME_RTR(frame))
    {
        // Ignores these frames.
        message->unref();
        return;
    }
 
    // We typecast the incoming buffer to a different buffer type that should be
    // the subset of the data.
    Buffer<CanMessageData> *incoming_buffer;
 
    // Checks that it fits.
    HASSERT(sizeof(*incoming_buffer) <= sizeof(*message));
    // Does the cast.
    incoming_buffer = static_cast<Buffer<CanMessageData> *>(
        static_cast<BufferBase *>(message));
    // Checks that the frame is still in the same place (by pointer).
    HASSERT(incoming_buffer->data()->mutable_frame() ==
            message->data()->mutable_frame());
 
    ifCan_->frame_dispatcher()->send(incoming_buffer, priority);
}
 
CanIf::CanIf(Service* service, CanHubFlow* device)
    : device_(device)
    , frameWriteFlow_(this)
    , frameReadFlow_(this)
    , frameDispatcher_(service) {
    this->device()->register_port(hub_port());
}
 
CanIf::~CanIf() {
    this->device()->unregister_port(hub_port());
}