oc_queue.c

Go to the documentation of this file.

#include <oc_object.h>
#include <oc_queue.h>
#include <oc_list.h>
#include <oc_stdlib.h>
#include <oc_null.h>
#include <oc_thread.h>
#include <oc_semaphore.h>
#include <oc_intman.h>

#define _________________________________________TYPES_SECTION______________________________________________________________________________

typedef struct Queue_t
{
    oC_ObjectControl_t      ObjectControl;
    oC_MemorySize_t         GetIndex;
    oC_MemorySize_t         PutIndex;
    oC_Semaphore_t          UsedSlotsSemaphore;
    oC_Semaphore_t          FreeSlotsSemaphore;
    oC_MemorySize_t         BufferSize;
    uint8_t                 Buffer[1];
} * Queue_t;

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________


#undef  _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________


#define _________________________________________FUNCTIONS_SECTION__________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_Queue_t oC_Queue_New( Allocator_t Allocator , oC_MemorySize_t BufferSize )
{
    Queue_t queue = NULL;

    if(
        oC_SaveIfFalse( "Allocator" , isaddresscorrect(Allocator), oC_ErrorCode_WrongAddress    )
     && oC_SaveIfFalse( "BufferSize", BufferSize > 0             , oC_ErrorCode_SizeNotCorrect  )
        )
    {
        queue = kmalloc( sizeof(struct Queue_t) + BufferSize, Allocator, AllocationFlags_ZeroFill );

        if( oC_SaveIfFalse( "queue" , queue != NULL, oC_ErrorCode_AllocationError ) )
        {
            queue->UsedSlotsSemaphore = oC_Semaphore_New(BufferSize,          0, Allocator, AllocationFlags_Default);
            queue->FreeSlotsSemaphore = oC_Semaphore_New(BufferSize, BufferSize, Allocator, AllocationFlags_Default);

            if(
                oC_SaveIfFalse( "used slots semaphore", queue->UsedSlotsSemaphore != NULL, oC_ErrorCode_AllocationError )
             && oC_SaveIfFalse( "free slots semaphore", queue->FreeSlotsSemaphore != NULL, oC_ErrorCode_AllocationError )
                )
            {
                queue->ObjectControl = oC_CountObjectControl( queue, oC_ObjectId_Queue );
                queue->BufferSize    = BufferSize;
                queue->GetIndex      = 0;
                queue->PutIndex      = 0;
            }
            else
            {
                if(queue->UsedSlotsSemaphore != NULL)
                {
                    oC_SaveIfFalse( "used slots", oC_Semaphore_Delete(&queue->UsedSlotsSemaphore,0), oC_ErrorCode_ReleaseError );
                }
                if(queue->FreeSlotsSemaphore != NULL)
                {
                    oC_SaveIfFalse( "free slots", oC_Semaphore_Delete(&queue->FreeSlotsSemaphore,0), oC_ErrorCode_ReleaseError );
                }
                oC_SaveIfFalse( "queue"     , kfree(queue,AllocationFlags_Default), oC_ErrorCode_ReleaseError );
                queue = NULL;
            }
        }
    }

    return queue;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Queue_Delete( oC_Queue_t * Queue )
{
    bool deleted = false;

    if(
        oC_SaveIfFalse("Queue", isram(Queue)                , oC_ErrorCode_AddressNotInRam  )
     && oC_SaveIfFalse("Queue", oC_Queue_IsCorrect(*Queue)  , oC_ErrorCode_ObjectNotCorrect )
        )
    {
        Queue_t    queue             = *Queue;
        bool       semaphore1deleted = oC_Semaphore_Delete(&queue->FreeSlotsSemaphore, 0);
        bool       semaphore2deleted = oC_Semaphore_Delete(&queue->UsedSlotsSemaphore, 0);
        bool       mainReleased      = kfree( queue, AllocationFlags_Default );

        deleted = oC_SaveIfFalse("Free slots semaphore", semaphore1deleted , oC_ErrorCode_ReleaseError)
               && oC_SaveIfFalse("Used slots semaphore", semaphore2deleted , oC_ErrorCode_ReleaseError)
               && oC_SaveIfFalse("Main object memory"  , mainReleased      , oC_ErrorCode_ReleaseError);
    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Queue_IsCorrect( oC_Queue_t Queue )
{
    return isram(Queue) && oC_CheckObjectControl(Queue, oC_ObjectId_Queue, ((Queue_t)Queue)->ObjectControl);
}
//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Queue_Put( oC_Queue_t Queue , const void * Data , uint32_t Size , oC_Time_t Timeout )
{
    bool    dataPushed = false;
    Queue_t queue      = Queue;

    if(
        oC_SaveIfFalse( "Queue"  , oC_Queue_IsCorrect(Queue), oC_ErrorCode_ObjectNotCorrect         )
     && oC_SaveIfFalse( "data"   , isaddresscorrect(Data)   , oC_ErrorCode_WrongAddress             )
     && oC_SaveIfFalse( "Size"   , Size > 0                 , oC_ErrorCode_SizeNotCorrect           )
     && oC_SaveIfFalse( "Timeout", Timeout >= 0             , oC_ErrorCode_TimeNotCorrect           )
        )
    {
        const uint8_t * buffer = Data;

        if(oC_Semaphore_TakeCounting(queue->FreeSlotsSemaphore,Size,Timeout))
        {
            oC_IntMan_EnterCriticalSection();

            for(oC_MemorySize_t i = 0; i < Size; i++)
            {
                queue->Buffer[queue->PutIndex++] = buffer[i];
                if(queue->PutIndex >= queue->BufferSize)
                {
                    queue->PutIndex = 0;
                }
            }
            oC_Semaphore_GiveCounting(queue->UsedSlotsSemaphore,Size);

            oC_IntMan_ExitCriticalSection();
            dataPushed = true;
        }
    }

    return dataPushed;
}
//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Queue_Get( oC_Queue_t Queue , void * outData , uint32_t Size , oC_Time_t Timeout )
{
    bool    dataReady = false;
    Queue_t queue     = Queue;

    if(
        oC_SaveIfFalse( "Queue"  , oC_Queue_IsCorrect(Queue)            , oC_ErrorCode_ObjectNotCorrect         )
     && oC_SaveIfFalse( "outData", isram(outData) || outData == NULL    , oC_ErrorCode_OutputAddressNotInRAM    )
     && oC_SaveIfFalse( "Size"   , Size > 0                             , oC_ErrorCode_SizeNotCorrect           )
     && oC_SaveIfFalse( "Timeout", Timeout >= 0                         , oC_ErrorCode_TimeNotCorrect           )
        )
    {
        uint8_t * outBuffer = outData;

        if(oC_Semaphore_TakeCounting(queue->UsedSlotsSemaphore,Size,Timeout))
        {
            oC_IntMan_EnterCriticalSection();

            for(oC_MemorySize_t i = 0; i < Size; i++)
            {
                if(outBuffer != NULL)
                {
                    outBuffer[i] = queue->Buffer[queue->GetIndex];
                }
                queue->GetIndex++;
                if(queue->GetIndex >= queue->BufferSize)
                {
                    queue->GetIndex = 0;
                }
            }
            oC_Semaphore_GiveCounting(queue->FreeSlotsSemaphore,Size);

            oC_IntMan_ExitCriticalSection();
            dataReady = true;
        }
    }

    return dataReady;
}

#undef  _________________________________________FUNCTIONS_SECTION__________________________________________________________________________