Controller.cpp

Go to the documentation of this file.

 
#include "rogue/protocols/packetizer/Controller.h"
 
#include <inttypes.h>
 
#include <cmath>
#include <memory>
 
#include "rogue/GeneralError.h"
#include "rogue/GilRelease.h"
#include "rogue/Helpers.h"
#include "rogue/interfaces/stream/Buffer.h"
#include "rogue/interfaces/stream/Frame.h"
#include "rogue/interfaces/stream/FrameLock.h"
#include "rogue/protocols/packetizer/Application.h"
#include "rogue/protocols/packetizer/Transport.h"
 
namespace rpp = rogue::protocols::packetizer;
namespace ris = rogue::interfaces::stream;
 
rpp::Controller::Controller(rpp::TransportPtr tran,
                            rpp::ApplicationPtr* app,
                            uint32_t headSize,
                            uint32_t tailSize,
                            uint32_t alignSize,
                            bool enSsi) {
    uint32_t x;
 
    enSsi_     = enSsi;
    app_       = app;
    tran_      = tran;
    appIndex_  = 0;
    tranIndex_ = 0;
    tranDest_  = 0;
    dropCount_ = 0;
    tranQueue_.setThold(64);
    log_ = rogue::Logging::create("packetizer.Controller");
 
    rogue::defaultTimeout(timeout_);
 
    headSize_  = headSize;
    tailSize_  = tailSize;
    alignSize_ = alignSize;
 
    for (x = 0; x < 256; x++) {
        transSof_[x]  = true;
        crc_[x]       = 0;
        tranCount_[x] = 0;
    }
}
 
rpp::Controller::~Controller() {
    this->stopQueue();
}
 
void rpp::Controller::stopQueue() {
    rogue::GilRelease noGil;
    tranQueue_.stop();
}
 
// Needs to be updated to support cascaded packetizers
ris::FramePtr rpp::Controller::reqFrame(uint32_t size) {
    ris::FramePtr lFrame;
    ris::FramePtr rFrame;
    ris::BufferPtr buff;
    uint32_t fSize;
 
    // Create frame container for request response
    lFrame = ris::Frame::create();
 
    // Align total size to configured alignment
    if ((size % alignSize_) != 0) size += (alignSize_ - (size % alignSize_));
 
    // Request individual frames upstream
    while (lFrame->getAvailable() < size) {
        // Generate a new size with header and tail
        fSize = (size - lFrame->getAvailable()) + headSize_ + tailSize_;
 
        // Pass request
        rFrame = tran_->reqFrame(fSize, false);
 
        // Take only the first buffer. This will break a cascaded packetizer
        // system. We need to fix this!
        buff = *(rFrame->beginBuffer());
 
        // Use buffer tail reservation to align available payload
        if (((buff->getAvailable() - tailSize_) % alignSize_) != 0)
            buff->adjustTail((buff->getAvailable() - tailSize_) % alignSize_);
 
        // Buffer should support our header/tail plus at least one payload byte
        if (buff->getAvailable() < (headSize_ + tailSize_ + 1))
            throw(rogue::GeneralError::create("packetizer::Controller::reqFrame",
                                              "Buffer size %" PRIu32 " is less than min size required %" PRIu32,
                                              buff->getAvailable(),
                                              (headSize_ + tailSize_ + 1)));
 
        // Add 8 bytes to head and tail reservation
        buff->adjustHeader(headSize_);
        buff->adjustTail(tailSize_);
 
        // Add buffer to return frame
        lFrame->appendBuffer(buff);
    }
    return (lFrame);
}
 
void rpp::Controller::transportRx(ris::FramePtr frame) {}
 
// Called by transport class thread
ris::FramePtr rpp::Controller::transportTx() {
    ris::FramePtr frame;
    frame = tranQueue_.pop();
    return (frame);
}
 
void rpp::Controller::applicationRx(ris::FramePtr frame, uint8_t tDest) {}
 
uint32_t rpp::Controller::getDropCount() {
    return (dropCount_);
}
 
void rpp::Controller::setTimeout(uint32_t timeout) {
    div_t divResult  = div(timeout, 1000000);
    timeout_.tv_sec  = divResult.quot;
    timeout_.tv_usec = divResult.rem;
}