workqueue.c

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.
 *
 ***************************************************************************/


#include <stdlib.h>
#include "FreeRTOS.h"
#include "task.h"
#include "workqueue.h"
#include "queue_simple.h"


typedef struct pvtWorkItem_t_ {

    DlNode_t Node;

    WorkItem_t Function;

    void *UserData;

} pvtWorkItem_t;


typedef struct pvtWorkQueue_t_ {

    Queue_t Queue;

    SemaphoreHandle_t Event;

    SemaphoreHandle_t Lock;

    TaskHandle_t WorkerThread;

#if (INCLUDE_vTaskDelete == 1)

    int ExitThread;

#endif

} pvtWorkQueue_t;



static void WorkerThread(void *parameters)
{
    /****************************************/
    pvtWorkQueue_t *WorkQueue;
    DlNode_t *Node;
    pvtWorkItem_t *WorkItem;

#if (INCLUDE_vTaskDelete == 1)

    TaskHandle_t handle;
    int ExitThread;

#endif
    /****************************************/


    WorkQueue = (pvtWorkQueue_t*)parameters;


    while (1) {

        xSemaphoreTake(WorkQueue->Event, portMAX_DELAY);

        xSemaphoreTake(WorkQueue->Lock, portMAX_DELAY);

        while ( !IsQueueEmpty(&WorkQueue->Queue)) {
            Node = Dequeue(&WorkQueue->Queue);

            xSemaphoreGive(WorkQueue->Lock);

            WorkItem = CONTAINING_RECORD(Node, pvtWorkItem_t, Node);

            WorkItem->Function(WorkItem->UserData);

            free(WorkItem);

            xSemaphoreTake(WorkQueue->Lock, portMAX_DELAY);
        }
    
#if (INCLUDE_vTaskDelete == 1)

        ExitThread = WorkQueue->ExitThread;

#endif

        xSemaphoreGive(WorkQueue->Lock);

#if (INCLUDE_vTaskDelete == 1)

        if (ExitThread) {
            break;
        }

#endif
    }

#if (INCLUDE_vTaskDelete == 1)
    
    xSemaphoreTake(WorkQueue->Lock, portMAX_DELAY);

    while ( !IsQueueEmpty(&WorkQueue->Queue)) {
        
        Node = Dequeue(&WorkQueue->Queue);

        WorkItem = CONTAINING_RECORD(Node, pvtWorkItem_t, Node);

        free(WorkItem);
    }

    xSemaphoreGive(WorkQueue->Lock);

    vSemaphoreDelete(WorkQueue->Lock);
    vSemaphoreDelete(WorkQueue->Event);

    handle = WorkQueue->WorkerThread;

    free(WorkQueue);

    vTaskDelete(handle);

#endif    
}


WorkQueue_t CreateWorkQueueEx(  const char * const Name,
                                uint16_t StackSize,
                                UBaseType_t Priority)
{
    /****************************/
    pvtWorkQueue_t *WorkQueue;
    BaseType_t rc;
    /****************************/
    
    WorkQueue = (pvtWorkQueue_t *)malloc(sizeof(pvtWorkQueue_t));

    if (WorkQueue == NULL)
        return NULL;

    InitQueue(&WorkQueue->Queue);

    WorkQueue->Event = xSemaphoreCreateBinary();

    if (WorkQueue->Event == NULL) {
        free(WorkQueue);
        return NULL;
    }

    WorkQueue->Lock = xSemaphoreCreateMutex();

    if (WorkQueue->Lock == NULL) {
        vSemaphoreDelete(WorkQueue->Event);
        free(WorkQueue);
        return NULL;
    }

#if (INCLUDE_vTaskDelete == 1)
 
    WorkQueue->ExitThread = 0;

#endif

    rc = xTaskCreate(   WorkerThread,
                        Name,
                        StackSize,
                        WorkQueue,
                        Priority,
                        &WorkQueue->WorkerThread);

    if (rc != pdPASS) {
        vSemaphoreDelete(WorkQueue->Lock);
        vSemaphoreDelete(WorkQueue->Event);
        free(WorkQueue);
        return NULL;
    }

    return WorkQueue;
}


#if (INCLUDE_vTaskDelete == 1)

void DestroyWorkQueue(WorkQueue_t wq)
{
    /****************************/
    pvtWorkQueue_t *WorkQueue;
    /****************************/

    WorkQueue = (pvtWorkQueue_t *)wq;

    xSemaphoreTake(WorkQueue->Lock, portMAX_DELAY);

    WorkQueue->ExitThread = 1;
    
    xSemaphoreGive(WorkQueue->Event);

    xSemaphoreGive(WorkQueue->Lock);
}

#endif


int QueueWorkItem(WorkQueue_t wq, WorkItem_t Function, void *UserData)
{
    /****************************/
    pvtWorkQueue_t *WorkQueue;
    pvtWorkItem_t *WorkItem;
    /****************************/

    WorkQueue = (pvtWorkQueue_t *)wq;

    WorkItem = (pvtWorkItem_t *)malloc(sizeof(pvtWorkItem_t));
    if (WorkItem == NULL) {
        return pdFAIL;
    }

    WorkItem->Function = Function;
    WorkItem->UserData = UserData;

    xSemaphoreTake(WorkQueue->Lock, portMAX_DELAY);

    Enqueue(&WorkQueue->Queue, &WorkItem->Node);
    
    xSemaphoreGive(WorkQueue->Event);

    xSemaphoreGive(WorkQueue->Lock);

    return pdPASS;
}