LibRtosTraceUsb.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "LibRtosTraceUsb.hpp"

LibRtosTraceUsb::LibRtosTraceUsb(int priority, size_t stackSize, uint8_t outEp, uint8_t inEp) :
        mTask(priority, "RTOS_TRACE", stackSize, *this), mUsbRxStream(outEp, 128), mUsbTxStream(inEp, 128) {
}

LibRtosTraceUsb::~LibRtosTraceUsb() {
}

void LibRtosTraceUsb::run() {
#if RTOS_CFG_TRACE_BUFFER_SIZE
    while (true) {
        mUsbRxStream.skip(128, Rtos::convertMsToTick(1000));
        mPktHandler.reset();
        bool isConnected = false;
        mTimer.set(Rtos::convertMsToTick(5000));
        while (true) {
            LibPktHandler::PKT* pkt;
            LibPktHandler::RESULT result = mPktHandler.recvPkt(mUsbRxStream, &pkt, 4);
            if (result == LibPktHandler::RES_SUCCESS) {
                mTimer.set(Rtos::convertMsToTick(5000));
                if(!isConnected) {
                    isConnected = true;
                    Rtos::clearTraceBuffer();
                }
                switch (pkt->hdr.cmd) {
                    case CMD_GET_TASK_NAME: {
                        RtosTask* task = (RtosTask*) ((uint32_t*) pkt->data)[0];
                        result = mPktHandler.sendPkt(mUsbTxStream, CMD_GET_TASK_NAME, strlen(task->getName()), task->getName(), Rtos::convertMsToTick(5000));
                        break;
                    }
                    case GET_CLOCK_FREQUENCY: {
                        uint32_t frequency = RTOS_CFG_CPU_FREQUENCY;
                        result =mPktHandler.sendPkt(mUsbTxStream, GET_CLOCK_FREQUENCY, 4, &frequency, Rtos::convertMsToTick(5000));
                        break;
                    }
                    case CMD_GET_TASK_STACK: {
                        RtosTask* task = (RtosTask*) ((uint32_t*) pkt->data)[0];
                        uint32_t param[3];
                        param[0] = (uint32_t) task;
                        param[1] = task->getStackSize();
                        param[2] = task->getFreeStackSize();
                        result = mPktHandler.sendPkt(mUsbTxStream, CMD_GET_TASK_STACK, sizeof(param), param, Rtos::convertMsToTick(5000));
                        break;
                    }
                    default:
                    break;
                }
                mPktHandler.freePkt(&pkt);
                if(result != LibPktHandler::RES_SUCCESS ) {
                    break;
                }
            }
            else if(mTimer.isEllapsed() && isConnected) {
                break;
            }

            if(isConnected) {
                Rtos::TRACE_TAG* tag;
                int count = Rtos::getTraceBuffer(&tag);
                if (count > 0) {
                    result = mPktHandler.sendPkt(mUsbTxStream, CMD_SEND_TRACE_TAGS, count * sizeof(Rtos::TRACE_TAG), tag, Rtos::convertMsToTick(5000));
                    if(result != LibPktHandler::RES_SUCCESS ) {
                        break;
                    }
                    Rtos::releaseBuffer(count);
                }
                else if (count < 0) { //Buffer full error
                    mPktHandler.sendPkt(mUsbTxStream, CMD_BUFFER_FULL, 0, 0, Rtos::convertMsToTick(5000));
                    break;
                }
            }
        }
    }
#endif
}