Task.cpp

/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved.                                                         */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib.  */
/*----------------------------------------------------------------------------*/

#include "Task.h"

#include "NetworkCommunication/UsageReporting.h"
#include "WPIErrors.h"
#include <errnoLib.h>
#include <string.h>
#include <taskLib.h>
#include <usrLib.h>

const uint32_t Task::kDefaultPriority;
const int32_t Task::kInvalidTaskID;

Task::Task(const char* name, FUNCPTR function, int32_t priority, uint32_t stackSize)
{
        m_taskID = kInvalidTaskID;
        m_function = function;
        m_priority = priority;
        m_stackSize = stackSize;
        m_taskName = new char[strlen(name) + 5];
        strcpy(m_taskName, "FRC_");
        strcpy(m_taskName+4, name);

        static int32_t instances = 0;
        instances++;
        nUsageReporting::report(nUsageReporting::kResourceType_Task, instances, 0, m_taskName);
}

Task::~Task()
{
        if (m_taskID != kInvalidTaskID) Stop();
        delete [] m_taskName;
        m_taskName = NULL;
}

bool Task::Start(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, 
                uint32_t arg5, uint32_t arg6, uint32_t arg7, uint32_t arg8, uint32_t arg9)
{
        m_taskID = taskSpawn(m_taskName,
                                                m_priority,
                                                VX_FP_TASK,                                                     // options
                                                m_stackSize,                                            // stack size
                                                m_function,                                                     // function to start
                                                arg0, arg1, arg2, arg3, arg4,   // parameter 1 - pointer to this class
                                                arg5, arg6, arg7, arg8, arg9);// additional unused parameters
        bool ok = HandleError(m_taskID);
        if (!ok) m_taskID = kInvalidTaskID;
        return ok;
}

bool Task::Restart()
{
        return HandleError(taskRestart(m_taskID));
}

bool Task::Stop()
{
        bool ok = true;
        if (Verify())
        {
                ok = HandleError(taskDelete(m_taskID));
        }
        m_taskID = kInvalidTaskID;
        return ok;
}

bool Task::IsReady()
{
        return taskIsReady(m_taskID);
}

bool Task::IsSuspended()
{
        return taskIsSuspended(m_taskID);
}

bool Task::Suspend()
{
        return HandleError(taskSuspend(m_taskID));
}

bool Task::Resume()
{
        return HandleError(taskResume(m_taskID));
}

bool Task::Verify()
{
        return taskIdVerify(m_taskID) == OK;
}

int32_t Task::GetPriority()
{
        if (HandleError(taskPriorityGet(m_taskID, &m_priority)))
                return m_priority;
        else
                return 0;
}

bool Task::SetPriority(int32_t priority)
{
        m_priority = priority;
        return HandleError(taskPrioritySet(m_taskID, m_priority));
}

const char* Task::GetName()
{
        return m_taskName;
}

int32_t Task::GetID()
{
        if (Verify())
                return m_taskID;
        return kInvalidTaskID;
}

bool Task::HandleError(STATUS results)
{
        if (results != ERROR) return true;
        switch(errnoGet())
        {
        case S_objLib_OBJ_ID_ERROR:
                wpi_setWPIErrorWithContext(TaskIDError, m_taskName);
                break;
                
        case S_objLib_OBJ_DELETED:
                wpi_setWPIErrorWithContext(TaskDeletedError, m_taskName);
                break;
                
        case S_taskLib_ILLEGAL_OPTIONS:
                wpi_setWPIErrorWithContext(TaskOptionsError, m_taskName);
                break;
                
        case S_memLib_NOT_ENOUGH_MEMORY:
                wpi_setWPIErrorWithContext(TaskMemoryError, m_taskName);
                break;
                
        case S_taskLib_ILLEGAL_PRIORITY:
                wpi_setWPIErrorWithContext(TaskPriorityError, m_taskName);
                break;

        default:
                printErrno(errnoGet());
                wpi_setWPIErrorWithContext(TaskError, m_taskName);
        }
        return false;
}