oc_event.c

Go to the documentation of this file.

#include <oc_event.h>
#include <oc_object.h>
#include <oc_stdlib.h>
#include <oc_threadman.h>
#include <oc_intman.h>
#include <oc_null.h>

#define _________________________________________TYPES_SECTION______________________________________________________________________________

struct Event_t
{
    oC_ObjectControl_t      ObjectControl;
    uint32_t                State;
    oC_Event_Protect_t      Protection;
};

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_Event_t oC_Event_New( oC_Event_State_t InitState , Allocator_t Allocator , AllocationFlags_t Flags )
{
    oC_Event_t event = ksmartalloc( sizeof(struct Event_t) , Allocator , Flags);

    if(event)
    {
        event->State         = InitState;
        event->ObjectControl = oC_CountObjectControl(event,oC_ObjectId_Event);
        event->Protection    = oC_Event_Protect_NotProtected;
    }
    else
    {
        oC_SaveError("Event: Creating new event" , oC_ErrorCode_AllocationError);
    }

    return event;
}


//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_Delete( oC_Event_t * Event , AllocationFlags_t Flags )
{
    bool deleted = false;

    if(oC_Event_IsCorrect(*Event))
    {
        if((*Event)->Protection == oC_Event_Protect_NotProtected)
        {
            oC_IntMan_EnterCriticalSection();

            oC_ThreadMan_UnblockAllBlockedBy(&(*Event)->State , false);
            (*Event)->ObjectControl = 0;

            if(ksmartfree(*Event,sizeof(struct Event_t),Flags))
            {
                *Event  = NULL;
                deleted = true;
            }
            else
            {
                oC_SaveError("Event: Delete" , oC_ErrorCode_ReleaseError);
            }

            oC_IntMan_ExitCriticalSection();
        }
        else
        {
            oC_SaveError("Event: Delete - " , oC_ErrorCode_ObjectProtected);
        }
    }
    else
    {
        oC_SaveError("Event: Delete - " , oC_ErrorCode_ObjectNotCorrect);
    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_ProtectDelete( oC_Event_t Event , Allocator_t Allocator , oC_Event_Protect_t Protection )
{
    bool success = false;

    if(oC_Event_IsCorrect(Event))
    {
        if(isaddresscorrect(Allocator))
        {
            if(Allocator != oC_MemMan_GetAllocatorOfAddress(Event))
            {
                oC_IntMan_EnterCriticalSection();

                Event->Protection = Protection;

                success = true;

                oC_IntMan_ExitCriticalSection();
            }
            else
            {
                oC_SaveError("Event: Protect delete - Allocator not correct (you are not owner of this event)" , oC_ErrorCode_WrongAddress );
            }
        }
        else
        {
            oC_SaveError("Event: Protect delete - Allocator not correct " , oC_ErrorCode_WrongAddress );
        }
    }
    else
    {
        oC_SaveError("Event: Protect delete - " , oC_ErrorCode_ObjectNotCorrect);
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_IsCorrect( oC_Event_t Event )
{
    return oC_MemMan_IsRamAddress(Event) && oC_CheckObjectControl(Event,oC_ObjectId_Event,Event->ObjectControl);
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Event_State_t oC_Event_GetState( oC_Event_t Event )
{
    return oC_Event_IsCorrect(Event) ? Event->State : 0;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_SetState( oC_Event_t Event , oC_Event_State_t State )
{
    bool set = false;

    if(oC_Event_IsCorrect(Event))
    {
        oC_IntMan_EnterCriticalSection();
        Event->State = State;

        // TODO: Uncomment line below when list will be faster
        // The line below unblocks all threads blocked by the event, but
        // it takes a lot of time and it must be called in an interrupt :/
//        oC_ThreadMan_UnblockAllBlockedBy(&Event->State , true);
        set          = true;
        oC_IntMan_ExitCriticalSection();
    }
    else
    {
        oC_SaveError("Event: set state" , oC_ErrorCode_ObjectNotCorrect);
    }

    return set;
}


//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_ClearStateBits( oC_Event_t Event , uint32_t StateMask )
{
    bool cleared = false;

    if(oC_Event_IsCorrect(Event))
    {
        oC_IntMan_EnterCriticalSection();
        Event->State &= ~StateMask;
        cleared       = true;
        oC_IntMan_ExitCriticalSection();
    }

    return cleared;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_ReadState( oC_Event_t Event , oC_Event_State_t * outState )
{
    bool read = false;

    if(oC_Event_IsCorrect(Event))
    {
        oC_IntMan_EnterCriticalSection();
        *outState = Event->State;
        read      = true;
        oC_IntMan_ExitCriticalSection();
    }
    else
    {
        oC_SaveError("Event: read state" , oC_ErrorCode_ObjectNotCorrect);
    }

    return read;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_WaitForState( oC_Event_t Event , oC_Event_State_t State , oC_Event_StateMask_t StateMask , oC_Time_t Timeout )
{
    bool stateOk = false;

    if(oC_Event_IsCorrect(Event))
    {
        oC_Thread_t thread = oC_ThreadMan_GetCurrentThread();

        if(StateMask != oC_Event_StateMask_DifferentThan)
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenEqual , State , StateMask , Timeout);
        }
        else
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenNotEqual , State , oC_Event_StateMask_Full , Timeout);
        }

        while(oC_Thread_IsBlocked(thread));

        oC_Thread_SetUnblocked(thread);

        oC_IntMan_EnterCriticalSection();

        if(oC_Event_IsCorrect(Event))
        {
            if(StateMask != oC_Event_StateMask_DifferentThan)
            {
                if((Event->State & StateMask) == (State & StateMask))
                {
                    stateOk = true;
                }
            }
            else
            {
                stateOk = (Event->State & oC_Event_StateMask_Full) != (State & oC_Event_StateMask_Full);
            }
        }
        oC_IntMan_ExitCriticalSection();
    }
    else
    {
        oC_SaveError("Event: wait for state" , oC_ErrorCode_ObjectNotCorrect);
    }

    return stateOk;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Event_WaitForValue( oC_Event_t Event , oC_Event_State_t Value , oC_Event_CompareType_t CompareType, oC_Time_t Timeout )
{
    bool stateOk = false;

    if(oC_Event_IsCorrect(Event) && CompareType < oC_Event_CompareType_NumberOfElements)
    {
        oC_Thread_t thread = oC_ThreadMan_GetCurrentThread();

        if(CompareType == oC_Event_CompareType_Equal)
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenEqual , Value, oC_Event_StateMask_Full, Timeout);
        }
        else if(CompareType == oC_Event_CompareType_Greater)
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenGreater, Value, oC_Event_StateMask_Full, Timeout);
        }
        else if(CompareType == oC_Event_CompareType_GreaterOrEqual)
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenGreaterOrEqual, Value, oC_Event_StateMask_Full, Timeout);
        }
        else if(CompareType == oC_Event_CompareType_Less)
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenSmaller, Value, oC_Event_StateMask_Full, Timeout);
        }
        else if(CompareType == oC_Event_CompareType_LessOrEqual)
        {
            oC_Thread_SetBlocked(thread, &Event->State , oC_Thread_Unblock_WhenSmallerOrEqual, Value, oC_Event_StateMask_Full, Timeout);
        }

        while(oC_Thread_IsBlocked(thread));

        oC_Thread_SetUnblocked(thread);

        oC_IntMan_EnterCriticalSection();

        if(oC_Event_IsCorrect(Event))
        {
            if(CompareType == oC_Event_CompareType_Equal)
            {
                stateOk = Event->State == Value;
            }
            else if(CompareType == oC_Event_CompareType_Greater)
            {
                stateOk = Event->State > Value;
            }
            else if(CompareType == oC_Event_CompareType_GreaterOrEqual)
            {
                stateOk = Event->State >= Value;
            }
            else if(CompareType == oC_Event_CompareType_Less)
            {
                stateOk = Event->State < Value;
            }
            else if(CompareType == oC_Event_CompareType_LessOrEqual)
            {
                stateOk = Event->State <= Value;
            }
        }
        oC_IntMan_ExitCriticalSection();
    }
    else
    {
        oC_SaveError("Event: wait for state" , oC_ErrorCode_ObjectNotCorrect);
    }

    return stateOk;
}

#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________