Call template provided (static) function

Question

I am trying to create a C++ wrapper for a freertos Task. The challenge here is that freertos needs to take a c function pointer as described here https://www.freertos.org/xTaskCreateStatic.html

Now I came up with this

template<typename Functor_T, uint32_t u32StackSize>
class CFreeRTOS_Task
{
public:
    ///Constructor
    CFreeRTOS_Task(const std::string& strTaskNameArg);
    ///Destructor
    ~CFreeRTOS_Task();

private:
    ///the Name of this task
    const std::string strTaskName;
    ///the task handle
    TaskHandle_t task;
    ///the task control block
    StaticTask_t task_tcb;
    ///is the task currently running (can be accessed from multiple threads => atomic)
    std::atomic<bool> bTaskRunning;
    ///the actual stack
    StackType_t stack[u32StackSize] = {};
    ///the task function to pass to freertos
    static void TaskFunction(void* pvParameters);
};

//+++++++++++++++++++++++++  Implementation +++++++++++++++++++++++++++++++++++++++++
template<typename Functor_T, uint32_t u32StackSize>
CFreeRTOS_Task<Functor_T, u32StackSize>::CFreeRTOS_Task(const std::string& strTaskNameArg) :
    strTaskName(strTaskNameArg)
{
    task = xTaskCreateStatic(
        TaskFunction, /* Function that implements the task. */
        strTaskName.c_str(), /* Text name for the task. */
        u32StackSize, /* Number of indexes in the xStack array. */
        (void*)1, /* Parameter passed into the task. */
        tskIDLE_PRIORITY,/* Priority at which the task is created. */
        stack, /* Array to use as the task's stack. */
        &task_tcb); /* Variable to hold the task's data structure. */
    bTaskRunning = true;
}
template<typename Functor_T, uint32_t u32StackSize>
CFreeRTOS_Task<Functor_T, u32StackSize>::~CFreeRTOS_Task()
{
    if (bTaskRunning)
    {
        //terminate task...
        bTaskRunning = false;
    }
}
template<typename Functor_T, uint32_t u32StackSize>
void CFreeRTOS_Task<Functor_T, u32StackSize>::TaskFunction(void* pvParameters)
{
    //do some initilisation
    for (;;)
    {
        //call the user provided task function
        Functor_T();
        osDelay(10);
    }
    //shutdown this task (common to all freertos tasks)
}

Now my instantiation looks like this

///test task function
static void TestTaskFunc();


///Test task instance
static CFreeRTOS_Task<TestTaskFunc,10> testTask("test_task");


static void TestTaskFunc()
{
    volatile uint32_t test = 0;
}

However I am getting 2 Compiler errors

error: type/value mismatch at argument 1 in template parameter list for 'template<class Functor_T, long unsigned int u32StackSize> class NRTOS_Wrapper::CFreeRTOS_Task'
static CFreeRTOS_Task<TestTaskFunc,10> testTask("test_task");
                                      ^
note:   expected a type, got 'NRTOS_Wrapper::TestTaskFunc'
error: invalid conversion from 'const char*' to 'int' [-fpermissive]

could you help me find out what I am missing here?

Miles Budnek · Accepted Answer · 2020-06-11T16:38:57.050

The way you have your class template written, Functor_T is a type not a value. There are a couple of places you've gotten tripped up by that:

static CFreeRTOS_Task<TestTaskFunc,10> testTask("test_task");

Here, you're trying to pass a value where CFreeRTOS_Task is expecting a type.

template<typename Functor_T, uint32_t u32StackSize>
void CFreeRTOS_Task<Functor_T, u32StackSize>::TaskFunction(void * pvParameters)
{
    //do some initilisation
    for(;;)
    {
        //call the user provided task function
        Functor_T();   // <---- HERE
        osDelay(10);
    }

    //shutdown this task (common to all freertos tasks)
}

Here you are value-initializing a temporary object of type Functor_T, not calling an existing functor object as the comment implies. Something like Functor_T()() could make sense for function-objects, but if Functor_T is a simple function pointer type (as in your example) that wouldn't make any sense.

It seems likely that what you actually need to do is store an object of the functor type in your class and then pass a pointer to that object to TaskFunction. For example:

template<typename Functor_T, uint32_t u32StackSize>
class CFreeRTOS_Task
{
public:
    ///Constructor
    CFreeRTOS_Task(std::string strTaskNameArg, Functor_T functor);
private:
    //...

    using Func_T = std::decay_t<Functor_T>;
    ///the functor to call
    Func_T mFunctor;

    ///the task function to pass to freertos
    static void TaskFunction(void* pvParameters);

};

template<typename Functor_T, uint32_t u32StackSize>
CFreeRTOS_Task<Functor_T, u32StackSize>::CFreeRTOS_Task(
    std::string strTaskNameArg,
    Functor_T functor
)
    : strTaskName{std::move(strTaskNameArg)},
      mFunctor{std::move(functor)}
{
    task = xTaskCreateStatic(
        TaskFunction, /* Function that implements the task. */
        strTaskName.c_str(), /* Text name for the task. */
        u32StackSize, /* Number of indexes in the xStack array. */
        &mFunctor, /* The functor to call, passed as a parameter into the task. */
      //^^^^^^^^^^ <---- HERE, pass a pointer to the functor as the task arg
        tskIDLE_PRIORITY,/* Priority at which the task is created. */
        stack, /* Array to use as the task's stack. */
        &task_tcb /* Variable to hold the task's data structure. */
    );
    bTaskRunning = true;
}

template<typename Functor_T, uint32_t u32StackSize>
void CFreeRTOS_Task<Functor_T, u32StackSize>::TaskFunction(void * pvParameters)
{
    //do some initilisation
    for(;;)
    {
        //cast the parameter back to a pointer to the correct functor type
        Func_T* pFunctor = reinterpret_cast<Func_T*>(pvParameters);
        //call the user provided task function
        (*pFunctor)();
        osDelay(10);
    }

    //shutdown this task (common to all freertos tasks)
}

Then at your call site, give the type of the functor as your CFreeRTOS_Task's template parameter and pass the value to its constructor:

///test task function
static void TestTaskFunc();


///Test task instance
static CFreeRTOS_Task<decltype(TestTaskFunc),10> testTask("test_task", TestTaskFunc);
                    //^^^^^^^^^^^^^^^^^^^^^^                           ^^^^^^^^^^^^
                    //Pass the type as a template parameter            And the value as a constructor parameter


static void TestTaskFunc()
{
    volatile uint32_t test = 0;
}

Live Demo

Thx you 2 for your quick answers :) Unfortunately this does not quite work. I suppose ``` (*Functor_T)();``` should actually be ```(*pFunctor)();``` right? However static cast fails ```invalid static_cast from type 'void*' to type 'void (*)()' Functor_T* pFunctor = static_cast(pvParameters); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~``` could you help me out here? — Dr.Death, Jun 11 '20 at 12:02
Oops, fixed. That should be a `reinterpret_cast` instead of `static_cast` and `(*pFunctor)()` instead of `(*Functor_T)()`. — Miles Budnek, Jun 11 '20 at 16:12
I also missed that `decltype(TestTaskFunc)` is `void()` rather than `void(*)()`. Added `using Func_T = std::decay_t` and switched to storing a `Func_T` to deal with that. Update again, now with a working demo. — Miles Budnek, Jun 11 '20 at 16:35

score 2 · Answer 2 · answered Jun 10 '20 at 21:14

The template type of the CFreeRTOS_Task is a pointer to a callable. Providing just TestTaskFunc will not deduce the type (i.e pointer to the function), instead, you need to decltype it.

static CFreeRTOS_Task<decltype(TestTaskFunc), 10> testTask("test_task");
//                    ^^^^^^^^

Call template provided (static) function

2 Answers2