Is there a mechanism for a new task to copy data pointed to by *pvParameters to be saved by the new task before the calling task (the one that calls xTaskCreate) erases the memory? So a structure is created on a local stack, xTaskCreate called, and returns When can the function release the stack memory – when has the new task taken its copy of the data? Do I need an interlock, a flag in the structure that is cleared by the new task when it has its copy, or another signalling method? Any suggestions or help gratefully received Regards Mike Newsome

If I get your question right, you have task A that creates task B, and task B wants some to copy some stack (that is not static) data from task A but does not know if the data is still valid or not as task A may have gone away and done something else. pvParameters being used to point to the data. You can achieve this by having task A create task B at a priority higher than task A. This way you are guaranteed that task B will run before task A even exits the xTaskCreate() function. Once task B has got the data it requires it can set its own priority to its real wanted value.

I had a situation where trimming task priorities resulted in a NULL pointer reference, which scared me slightly. Also the code to start the new task was a function call used by lots of tasks of differing priorities. The way I got round this was to use pvPortMalloc() and let the newly generated task free the memory using vPortFree(). WHAT DOES THE CODE DO? Its a one shot timer. It fires off a new tasks that waits for the specified period of time, posts a message to a queue and then destroys itself. HOW? I allocate memory for a ‘param_*’ struct and stuff it with local variables from calling task A new task is started and receives a pointer to the struct. The struct is cast to access data. Once used it can be freed. CONCLUSION It did strike me as a safe way, but rather long winded. Has anyone else solved this problem in a less round about way? CODE… typedef struct prt_param_oneshottimer_t {    portTickType timerperiod;    uint32_t event;    uint32_t data; }param_oneshottimer_t; int TaskStart_OneShotTimer (portTickType timerperiod, uint32_t event, uint32_t data) {    int retval = PASS;    param_oneshottimer_t *param_oneshottimer;    // Allocate storage for the timer variables. Pointer to this is    // passed to the task and used by the task created    param_oneshottimer = ( param_oneshottimer_t * )       pvPortMalloc( sizeof( param_oneshottimer_t ) );    // Assign passed arguments to the task    param_oneshottimer->timerperiod = timerperiod;    param_oneshottimer->event = event;    param_oneshottimer->data = data;    // Pass arguments to the task that starts the timer    if (xTaskCreate        (Task_OneShotTimer, "OneShotTimer", TASKSTACK_TIMER,         (void *)param_oneshottimer, (tskIDLE_PRIORITY + 3),         (xTaskHandle *) NULL) != PASS)    {       retval = FAIL;    }    return (retval); } static portTASK_FUNCTION (Task_OneShotTimer, pvParameters) {    // Cast data passed to task    param_oneshottimer_t *prt_param_oneshottimer;    prt_param_oneshottimer = (param_oneshottimer_t *) pvParameters;    // Wait for the specified period of time    vTaskDelay(prt_param_oneshottimer->timerperiod);    // We have waited the required amount of time. Post the required    // message to the queue    MessageQueueSendData(prt_param_oneshottimer->event,     prt_param_oneshottimer->data, "oneshottimer");    // Deallocate memory used    vPortFree( (void *)prt_param_oneshottimer );    // Now delete the task    vTaskDelete (NULL); }

Hi Dave You have the question right! Thanks for an answer. I quite like the look of Jons solution, although as he says it is a bit long winded. Regards Mike Newsome