scheduler_task.hpp

Go to the documentation of this file.

/*
 *     SocialLedge.com - Copyright (C) 2013
 *
 *     This file is part of free software framework for embedded processors.
 *     You can use it and/or distribute it as long as this copyright header
 *     remains unmodified.  The code is free for personal use and requires
 *     permission to use in a commercial product.
 *
 *      THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
 *      OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
 *      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
 *      I SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
 *      CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 *     You can reach the author of this software at :
 *          p r e e t . w i k i @ g m a i l . c o m
 */

#ifndef CPP_TASK_HPP_
#define CPP_TASK_HPP_
#include <stdint.h>

#include "FreeRTOS.h"
#include "queue.h"
#include "task.h"



class scheduler_task;


void scheduler_add_task(scheduler_task *task);

void scheduler_start(bool dbg_print=false, bool register_internal_tlm=false);


class scheduler_task
{
    public :
        static scheduler_task* getTaskPtrByName(const char *);

        inline const char*  getTaskName(void)     const { return mName;      }
        inline uint32_t     getFreeStack(void)    const { return mFreeStack; }
        inline uint32_t     getRunCount(void)     const { return mRunCount;  }
        inline TaskHandle_t getTaskHandle(void)   const { return mHandle;    }
        inline uint8_t      getTaskPriority(void) const { return mPriority;  }
        uint8_t getTaskCpuPercent(void) const;   
        static uint8_t getSysCpuPercent (void);  
        static uint8_t getSysIdlePercent(void);  

        inline void suspend(void) const { vTaskSuspend(mHandle); }
        inline void resume (void) const { vTaskResume(mHandle);  }
        static bool  addSharedObject(const char *name, void *obj_ptr);
        static void* getSharedObject(const char *name);
        static bool  addSharedObject(uint8_t index, void *obj_ptr);
        static void* getSharedObject(uint8_t index);
    protected:
        scheduler_task(const char *name, uint32_t stack, uint8_t priority, void *param=0);
        virtual ~scheduler_task() {}

        virtual bool init(void)   { return true; }

        virtual bool regTlm(void) { return true; }

        virtual bool taskEntry(void) { return true; }

        virtual bool run(void *param)=0;

        inline void setRunDuration(uint32_t milliseconds) { mTaskDelayMs = milliseconds; }

        inline uint32_t getRunDuration(void) const { return mTaskDelayMs; }

    #if (0 != configUSE_QUEUE_SETS)

        void initQueueSet(uint32_t queueSetSize, uint32_t count, ...);

        inline void setQueueSetBlockTime(TickType_t t) { mQueueSetBlockTime = t; }
        inline QueueSetHandle_t getQueueSetSelection(void) { return mQueueSetType; }
    #endif

        inline void setStatUpdateRate(uint32_t rateMs) { mStatUpdateRateMs = rateMs; }

    private:
        /* Hide the constructor that user is not supposed to use.
         * Need this for const member initialization
         */
        scheduler_task() :
    #if (0 != configUSE_QUEUE_SETS)
            mQueueSet(0), mQueueSetType(0), mQueueSetBlockTime(0),
    #endif
            mHandle(0), mFreeStack(0), mRunCount(0), mTaskDelayMs(0), mStatUpdateRateMs(0),
            mName(0), mParam(0), mStackSize(0), mPriority(0) {}

    #if (0 != configUSE_QUEUE_SETS)

        QueueSetHandle_t mQueueSet;           
        QueueSetMemberHandle_t mQueueSetType; 
        TickType_t mQueueSetBlockTime;        

    #endif

        TaskHandle_t mHandle;       
        uint32_t mFreeStack;        
        uint32_t mRunCount;         
        uint32_t mTaskDelayMs;      
        uint32_t mStatUpdateRateMs; 

        const char *mName;          
        const void *mParam;         
        const uint32_t mStackSize;  
        const uint8_t mPriority;    

        friend bool scheduler_init_all(bool register_task_tlm);
        friend void scheduler_c_task_private(void *param);
};



#endif /* CPP_TASK_HPP_ */