thread.hpp

Go to the documentation of this file.

/****************************************************************************
 *
 *  Copyright (c) 2017, Michael Becker (michael.f.becker@gmail.com)
 *
 *  This file is part of the FreeRTOS Add-ons project.
 *
 *  Source Code:
 *  https://github.com/michaelbecker/freertos-addons
 *
 *  Project Page:
 *  http://michaelbecker.github.io/freertos-addons/
 *
 *  On-line Documentation:
 *  http://michaelbecker.github.io/freertos-addons/docs/html/index.html
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a
 *  copy of this software and associated documentation files
 *  (the "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so,subject to the
 *  following conditions:
 *
 *  + The above copyright notice and this permission notice shall be included
 *    in all copies or substantial portions of the Software.
 *  + Credit is appreciated, but not required, if you find this project
 *    useful enough to include in your application, product, device, etc.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 *  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 *  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 *  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 ***************************************************************************/
 
 
#ifndef THREAD_HPP_
#define THREAD_HPP_
 
#ifndef CPP_FREERTOS_NO_CPP_STRINGS
#include <string>
#endif
#include "FreeRTOS.h"
#include "task.h"
#include "mutex.hpp"
#include "semaphore.hpp"
#include "condition_variable.hpp"
 
namespace cpp_freertos {
 
 
class Thread {
 
    //
    //  Public API
    //  Available from anywhere. Many of these require a Thread reference
    //  if they are operating on a thread.
    //
    public:
#ifndef CPP_FREERTOS_NO_CPP_STRINGS
        Thread( const std::string Name,
                uint16_t StackDepth,
                UBaseType_t Priority);
#else
        Thread( const char *Name,
                uint16_t StackDepth,
                UBaseType_t Priority);
#endif
 
        Thread( uint16_t StackDepth,
                UBaseType_t Priority);
 
        bool Start();
 
        virtual ~Thread();
 
        inline TaskHandle_t GetHandle()
        {
            return handle;
        }
 
        static inline void Yield()
        {
            taskYIELD();
        }
 
        static inline void StartScheduler()
        {
            SchedulerActive = true;
            vTaskStartScheduler();
        }
 
        static inline void EndScheduler()
        {
            vTaskEndScheduler();
            SchedulerActive = false;
        }
 
#if (INCLUDE_vTaskSuspend == 1)
        inline void Suspend()
        {
            vTaskSuspend(GetHandle());
        }
 
        inline void Resume()
        {
            vTaskResume(GetHandle());
        }
#endif
 
#if (INCLUDE_xTaskResumeFromISR == 1)
        inline void ResumeFromISR()
        {
            xTaskResumeFromISR(GetHandle());
        }
#endif
 
#ifdef configUSE_TASK_NOTIFICATIONS
    inline void Notify()
    {
        xTaskNotifyGive( GetHandle() );
    }
 
    inline void NotifyFromISR()
    {
        BaseType_t pxHigherPriorityTaskWoken;
        vTaskNotifyGiveFromISR( GetHandle(), &pxHigherPriorityTaskWoken );
        portYIELD_FROM_ISR(pxHigherPriorityTaskWoken);
    }
 
    inline uint32_t WaitForNotification( TickType_t Timeout = portMAX_DELAY )
    {
        return ulTaskNotifyTake( pdTRUE, Timeout );
    }
#endif
 
#if (INCLUDE_uxTaskPriorityGet == 1)
        inline UBaseType_t GetPriority()
        {
            return (uxTaskPriorityGet(GetHandle()));
        }
 
        inline UBaseType_t GetPriorityFromISR()
        {
            return (uxTaskPriorityGetFromISR(GetHandle()));
        }
#endif
 
 
#if (INCLUDE_vTaskPrioritySet == 1)
        inline void SetPriority(UBaseType_t NewPriority)
        {
            Priority = NewPriority;
            vTaskPrioritySet(GetHandle(), NewPriority);
        }
#endif
 
#ifndef CPP_FREERTOS_NO_CPP_STRINGS
        inline std::string GetName()
        {
            return Name;
        }
#else
        inline char* GetName()
        {
            return pcTaskGetName(handle);
        }
#endif
 
    //
    //  Protected API
    //  Available from inside your Thread implementation.
    //  You should make sure that you are only calling these methods
    //  from within your Run() method, or that your Run() method is on the
    //  callstack.
    //
    protected:
        virtual void Run() = 0;
 
#if (INCLUDE_vTaskDelete == 1)
        virtual void Cleanup();
#else
#endif
 
#if (INCLUDE_vTaskDelay == 1)
        void inline Delay(const TickType_t Delay)
        {
            vTaskDelay(Delay);
        }
#endif
 
#if (INCLUDE_vTaskDelayUntil == 1)
        void DelayUntil(const TickType_t Period);
 
        void ResetDelayUntil();
#endif
 
 
#ifdef CPP_FREERTOS_CONDITION_VARIABLES
 
        bool Wait(  ConditionVariable &Cv,
                    Mutex &CvLock,
                    TickType_t Timeout = portMAX_DELAY);
 
#endif
 
 
    //
    //  Private API
    //  The internals of this wrapper class.
    //
    private:
        TaskHandle_t handle;
 
        static volatile bool SchedulerActive;
 
#ifndef CPP_FREERTOS_NO_CPP_STRINGS
        const std::string Name;
#else
        char Name[configMAX_TASK_NAME_LEN];
#endif
 
        const uint16_t StackDepth;
 
        UBaseType_t Priority;
 
        bool ThreadStarted;
        
        static MutexStandard StartGuardLock;
 
        static void TaskFunctionAdapter(void *pvParameters);
 
#if (INCLUDE_vTaskDelayUntil == 1)
        bool delayUntilInitialized;
 
        TickType_t delayUntilPreviousWakeTime;
#endif
 
#ifdef CPP_FREERTOS_CONDITION_VARIABLES
 
        BinarySemaphore ThreadWaitSem;
 
        inline void Signal()
        {
            ThreadWaitSem.Give();
        }
 
    friend class ConditionVariable;
 
#endif
 
 
};
 
 
}
#endif