eive-obsw/linux/obc/PapbVcInterface.cpp

#include <linux/obc/PapbVcInterface.h>
#include <fsfw_hal/linux/uio/UioMapper.h>
#include "fsfw/serviceinterface/ServiceInterface.h"

PapbVcInterface::PapbVcInterface(object_id_t objectId, LinuxLibgpioIF* gpioComIF,
        gpioId_t papbBusyId, gpioId_t papbEmptyId, std::string uioFile, int mapNum) :
        SystemObject(objectId), gpioComIF(gpioComIF), papbBusyId(papbBusyId), papbEmptyId(
                papbEmptyId), uioFile(uioFile), mapNum(mapNum) {
}

PapbVcInterface::~PapbVcInterface() {
}

ReturnValue_t PapbVcInterface::initialize() {
    UioMapper uioMapper(uioFile, mapNum);
    return uioMapper.getMappedAdress(&vcBaseReg, UioMapper::Permissions::WRITE_ONLY);
}

ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
    if (pollPapbBusySignal() == RETURN_OK) {
        startPacketTransfer();
    }
    for (size_t idx = 0; idx < size; idx++) {
        if (pollPapbBusySignal() == RETURN_OK) {
            *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(*(data + idx));
        } else {
            sif::warning << "PapbVcInterface::write: Only written " << idx << " of " << size
                    << " data" << std::endl;
            return RETURN_FAILED;
        }
    }
    if (pollPapbBusySignal() == RETURN_OK) {
        endPacketTransfer();
    }
    return RETURN_OK;
}

void PapbVcInterface::startPacketTransfer() {
    *vcBaseReg = CONFIG_START;
}

void PapbVcInterface::endPacketTransfer() {
    *vcBaseReg = CONFIG_END;
}

ReturnValue_t PapbVcInterface::pollPapbBusySignal() {
    int papbBusyState = 0;
    ReturnValue_t result = RETURN_OK;

    /** Check if PAPB interface is ready to receive data */
    result = gpioComIF->readGpio(papbBusyId, &papbBusyState);
    if (result != RETURN_OK) {
        sif::warning << "PapbVcInterface::pollPapbBusySignal: Failed to read papb busy signal"
                << std::endl;
        return RETURN_FAILED;
    }
    if (!papbBusyState) {
        sif::warning << "PapbVcInterface::pollPapbBusySignal: PAPB busy" << std::endl;
        return PAPB_BUSY;
    }

    return RETURN_OK;
}

void PapbVcInterface::isVcInterfaceBufferEmpty() {
    ReturnValue_t result = RETURN_OK;
    int papbEmptyState = 1;

    result = gpioComIF->readGpio(papbEmptyId, &papbEmptyState);

    if (result != RETURN_OK) {
        sif::warning
                << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
                << std::endl;
        return;
    }

    if (papbEmptyState == 1) {
        sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is empty" << std::endl;
    } else {
        sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is not empty" << std::endl;
    }
    return;
}

ReturnValue_t PapbVcInterface::sendTestFrame() {
    /** Size of one complete transfer frame data field amounts to 1105 bytes */
    uint8_t testPacket[1105];

    /** Fill one test packet */
    for (int idx = 0; idx < 1105; idx++) {
        testPacket[idx] = static_cast<uint8_t>(idx & 0xFF);
    }

    ReturnValue_t result = write(testPacket, 1105);
    if (result != RETURN_OK) {
        return result;
    }

    return RETURN_OK;
}