oc_gpio.c

Go to the documentation of this file.

#include <oc_gpio.h>
#include <oc_gpio_lld.h>
#include <oc_compiler.h>
#include <oc_module.h>
#include <oc_intman.h>
#include <oc_null.h>
#include <string.h>
#include <oc_event.h>

#define _________________________________________DRIVER_DEFINITIONS_SECTION_________________________________________________________________

#define DRIVER_SOURCE

/* Driver basic definitions */
#define DRIVER_NAME         GPIO
#define DRIVER_FILE_NAME    "gpio"
#define DRIVER_VERSION      oC_Driver_MakeVersion(1,0,0)
#define REQUIRED_DRIVERS
#define REQUIRED_BOOT_LEVEL oC_Boot_Level_RequireMemoryManager | oC_Boot_Level_RequireDriversManager

/* Driver interface definitions */
#define DRIVER_CONFIGURE    oC_GPIO_Configure
#define DRIVER_UNCONFIGURE  oC_GPIO_Unconfigure
#define DRIVER_TURN_ON      oC_GPIO_TurnOn
#define DRIVER_TURN_OFF     oC_GPIO_TurnOff
#define IS_TURNED_ON        oC_GPIO_IsTurnedOn
#define HANDLE_IOCTL        oC_GPIO_Ioctl

#undef  _________________________________________DRIVER_DEFINITIONS_SECTION_________________________________________________________________

/* This header must be always at the end of include list */
#include <oc_driver.h>

#define _________________________________________VARIABLES_SECTION__________________________________________________________________________

static       oC_Event_t     InterruptEvent  = NULL;
static const oC_Allocator_t Allocator       = {
                .Name = "gpio"
};

#undef  _________________________________________VARIABLES_SECTION__________________________________________________________________________

#define _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________

static void InterruptHandler( oC_Pins_t Pins );

#undef  _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________


#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_TurnOn( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    oC_IntMan_EnterCriticalSection();

    if(oC_Module_TurnOffVerification(&errorCode , oC_Module_GPIO))
    {
        errorCode = oC_GPIO_LLD_TurnOnDriver();

        if(errorCode == oC_ErrorCode_ModuleIsTurnedOn)
        {
            errorCode = oC_ErrorCode_None;
        }

        if(!oC_ErrorOccur(errorCode))
        {
            InterruptEvent = oC_Event_New(oC_Event_State_Inactive , &Allocator , AllocationFlags_CanWait1Second);

            if(
                ErrorCondition( oC_Event_IsCorrect(InterruptEvent) , oC_ErrorCode_AllocationError) &&
                oC_AssignErrorCode( &errorCode , oC_GPIO_LLD_SetDriverInterruptHandler(InterruptHandler))
                )
            {
                oC_Module_TurnOn(oC_Module_GPIO);
                errorCode = oC_ErrorCode_None;
            }
        }

    }

    oC_IntMan_ExitCriticalSection();

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_TurnOff( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    oC_IntMan_ExitCriticalSection();

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        /* This must be at the start of the function */
        oC_Module_TurnOff(oC_Module_GPIO);

        errorCode = oC_GPIO_LLD_TurnOffDriver();

        if(errorCode == oC_ErrorCode_ModuleNotStartedYet)
        {
            errorCode = oC_ErrorCode_None;
        }

        if(!oC_Event_Delete(&InterruptEvent,AllocationFlags_CanWaitForever))
        {
            errorCode = oC_ErrorCode_CannotDeleteObject;
        }
    }

    oC_IntMan_ExitCriticalSection();

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_GPIO_IsTurnedOn( void )
{
    return oC_Module_IsTurnedOn(oC_Module_GPIO);
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_Configure( const oC_GPIO_Config_t * Config , oC_GPIO_Context_t * outContext )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        if(
            oC_AssignErrorCodeIfFalse(&errorCode , isaddresscorrect(Config) , oC_ErrorCode_WrongConfigAddress) &&
            oC_AssignErrorCodeIfFalse(&errorCode , isram(outContext)        , oC_ErrorCode_OutputAddressNotInRAM)
            )
        {
            oC_Pins_t pins              = Config->Pins;
            bool      unlocked          = false;
            bool      used              = false;
            oC_Pins_t * pinsReference   = ksmartalloc(sizeof(oC_Pins_t),&Allocator,AllocationFlags_CanWait1Second);


            oC_IntMan_EnterCriticalSection();
            if(
                oC_AssignErrorCodeIfFalse(&errorCode , isram(pinsReference) , oC_ErrorCode_AllocationError ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration( pins))  &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_CheckIsPinUnlocked(pins,&unlocked) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_CheckIsPinUsed(pins,&used) ) &&
                oC_AssignErrorCodeIfFalse(&errorCode , used == false , oC_ErrorCode_PinIsUsed ) &&
                (unlocked == true || oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_UnlockProtection(pins,Config->Protection) )) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetSpeed(pins,Config->Speed) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetCurrent(pins,Config->Current) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetMode(pins,Config->Mode) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPull(pins,Config->Pull) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetOutputCircuit(pins,Config->OutputCircuit) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetInterruptTrigger(pins,Config->InterruptTrigger) ) &&
                oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(pins))
                )
            {
                *pinsReference  = pins;
                *outContext     = pinsReference;
                errorCode       = oC_ErrorCode_None;
            }
            else
            {
                if(used)
                {
                    oC_ErrorCode_t tempErrorCode = oC_GPIO_LLD_SetPinsUnused(pins);

                    if(oC_ErrorOccur(tempErrorCode))
                    {
                        oC_SaveError("GPIO-Cfg/Setting pins unused" , tempErrorCode);
                    }
                }
                if(pinsReference)
                {
                    if(ksmartfree(pinsReference,sizeof(oC_Pins_t),AllocationFlags_CanWaitForever)==false)
                    {
                        oC_SaveError("GPIO-Cfg/release context" , oC_ErrorCode_ReleaseError);
                    }
                }
            }
            oC_IntMan_ExitCriticalSection();
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_Unconfigure( const oC_GPIO_Config_t * Config , oC_GPIO_Context_t * outContext )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        if(
            oC_AssignErrorCodeIfFalse(&errorCode , isaddresscorrect(Config) , oC_ErrorCode_WrongConfigAddress) &&
            oC_AssignErrorCodeIfFalse(&errorCode , isram(outContext)        , oC_ErrorCode_OutputAddressNotInRAM)
            )
        {
            errorCode = oC_GPIO_LLD_SetPinsUnused(Config->Pins);

            if(ksmartfree(*outContext,sizeof(oC_Pins_t),AllocationFlags_CanWaitForever)==false)
            {
                errorCode = oC_ErrorCode_ReleaseError;
            }
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_Ioctl( oC_GPIO_Context_t Context , oC_Ioctl_Command_t Command , void * Data )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO) &&
        oC_AssignErrorCodeIfFalse(&errorCode , isaddresscorrect(Context) , oC_ErrorCode_WrongAddress)
        )
    {
        switch(Command)
        {
            //==============================================================================================================================
            /*
             * Toggle pins command
             */
            //==============================================================================================================================
            case oC_GPIO_Ioctl_Command_TogglePins:
                oC_GPIO_LLD_TogglePinsState(*Context);
                errorCode = oC_ErrorCode_None;
                break;
            //==============================================================================================================================
            /*
             * Set pins state command
             */
            //==============================================================================================================================
            case oC_GPIO_Ioctl_Command_SetPinsState:
                if(oC_AssignErrorCodeIfFalse(&errorCode,isaddresscorrect(Data),oC_ErrorCode_WrongAddress))
                {
                    oC_GPIO_LLD_SetPinsState(*Context , gen_point_value(oC_GPIO_LLD_PinsState_t,Data));
                    errorCode = oC_ErrorCode_None;
                }
                break;
            //==============================================================================================================================
            /*
             * Get high pins state command
             */
            //==============================================================================================================================
            case oC_GPIO_Ioctl_Command_GetHighPinsState:
                if(
                    oC_AssignErrorCodeIfFalse(&errorCode,isram(Data),oC_ErrorCode_OutputAddressNotInRAM) &&
                    oC_AssignErrorCodeIfFalse(&errorCode,oC_GPIO_LLD_ArePinsCorrect(*Context),oC_ErrorCode_GPIOPinIncorrect)
                    )
                {
                    gen_point_value(oC_GPIO_LLD_PinsState_t,Data) = oC_GPIO_LLD_GetHighStatePins(*Context);
                    errorCode                                     = oC_ErrorCode_None;
                }
                break;
            //==============================================================================================================================
            /*
             * Get low pins state command
             */
            //==============================================================================================================================
            case oC_GPIO_Ioctl_Command_GetLowPinsState:
                if(
                    oC_AssignErrorCodeIfFalse(&errorCode,isram(Data),oC_ErrorCode_OutputAddressNotInRAM) &&
                    oC_AssignErrorCodeIfFalse(&errorCode,oC_GPIO_LLD_ArePinsCorrect(*Context),oC_ErrorCode_GPIOPinIncorrect)
                    )
                {
                    gen_point_value(oC_GPIO_LLD_PinsState_t,Data) = oC_GPIO_LLD_GetHighStatePins(*Context);
                    errorCode                                     = oC_ErrorCode_None;
                }
                break;
            //==============================================================================================================================
            /*
             * Not handled commands
             */
            //==============================================================================================================================
            default:
                errorCode = oC_ErrorCode_CommandNotHandled;
                break;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_QuickOutput( oC_Pins_t Pins )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        bool      unlocked          = false;
        bool      used              = false;

        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration( Pins))  &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_CheckIsPinUnlocked(Pins,&unlocked) ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_CheckIsPinUsed(Pins,&used) ) &&
            oC_AssignErrorCodeIfFalse(&errorCode , used == false , oC_ErrorCode_PinIsUsed ) &&
            oC_AssignErrorCodeIfFalse(&errorCode , unlocked      , oC_ErrorCode_GPIOPinNeedUnlock ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetMode(Pins,oC_GPIO_Mode_Output) ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetOutputCircuit(Pins,oC_GPIO_OutputCircuit_PushPull) ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode       = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_QuickInput( oC_Pins_t Pins , oC_GPIO_Pull_t Pull )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        bool      unlocked          = false;
        bool      used              = false;

        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_CheckIsPinUnlocked(Pins,&unlocked) ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_CheckIsPinUsed(Pins,&used) ) &&
            oC_AssignErrorCodeIfFalse(&errorCode , used == false , oC_ErrorCode_PinIsUsed ) &&
            oC_AssignErrorCodeIfFalse(&errorCode , unlocked      , oC_ErrorCode_GPIOPinNeedUnlock ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration( Pins))  &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetMode(Pins,oC_GPIO_Mode_Input) ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPull(Pins,Pull) ) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode       = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_QuickUnconfigure( oC_Pins_t Pins )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        errorCode = oC_GPIO_LLD_SetPinsUnused(Pins);
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_SetSpeed( oC_Pins_t Pins , oC_GPIO_Speed_t Speed )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pins)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetSpeed(Pins,Speed)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_ReadSpeed( oC_Pins_t Pins , oC_GPIO_Speed_t * outSpeed )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();

        if(oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ReadSpeed(Pins,(oC_GPIO_LLD_Speed_t*)outSpeed)))
        {
            errorCode = oC_ErrorCode_None;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_SetCurrent( oC_Pins_t Pins , oC_GPIO_Current_t Current )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pins)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetCurrent(Pins,Current)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_ReadCurrent( oC_Pins_t Pins , oC_GPIO_Current_t * outCurrent )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();

        if(oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ReadCurrent(Pins,(oC_GPIO_LLD_Current_t*)outCurrent)))
        {
            errorCode = oC_ErrorCode_None;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_SetMode( oC_Pins_t Pins , oC_GPIO_Mode_t Mode )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pins)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetMode(Pins,Mode)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_ReadMode( oC_Pins_t Pins , oC_GPIO_Mode_t * outMode )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();

        if(oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ReadMode(Pins,(oC_GPIO_LLD_Mode_t*)outMode)))
        {
            errorCode = oC_ErrorCode_None;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_SetPull( oC_Pins_t Pins , oC_GPIO_Pull_t Pull )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pins)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPull(Pins,Pull)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_ReadPull( oC_Pins_t Pins , oC_GPIO_Pull_t * outPull )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();

        if(oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ReadPull(Pins,(oC_GPIO_LLD_Pull_t*)outPull)))
        {
            errorCode = oC_ErrorCode_None;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_SetOutputCircuit( oC_Pins_t Pins , oC_GPIO_OutputCircuit_t OutputCircuit )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pins)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetOutputCircuit(Pins,OutputCircuit)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_ReadOutputCircuit( oC_Pins_t Pins , oC_GPIO_OutputCircuit_t * outOutputCircuit )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();

        if(oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ReadOutputCircuit(Pins,(oC_GPIO_LLD_OutputCircuit_t*)outOutputCircuit)))
        {
            errorCode = oC_ErrorCode_None;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_SetInterruptTrigger( oC_Pins_t Pins , oC_GPIO_IntTrigger_t InterruptTrigger )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();
        if(
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_BeginConfiguration(Pins)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetInterruptTrigger(Pins,InterruptTrigger)) &&
            oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_FinishConfiguration(Pins))
            )
        {
            errorCode = oC_ErrorCode_None;
        }
        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_ReadInterruptTrigger( oC_Pins_t Pins , oC_GPIO_IntTrigger_t * outInterruptTrigger )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        oC_IntMan_EnterCriticalSection();

        if(oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ReadInterruptTrigger(Pins,(oC_GPIO_LLD_IntTrigger_t*)outInterruptTrigger)))
        {
            errorCode = oC_ErrorCode_None;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}


const char * oC_GPIO_GetCurrentNameFromEnum(oC_GPIO_Current_t Current)
{
    char * name = malloc(sizeof(name)   , 10);

    switch(Current)
    {
        case oC_GPIO_Current_Default:
            name = "Default";
            break;
        case oC_GPIO_Current_Minimum:
            name = "Minimum";
            break;
        case oC_GPIO_Current_Medium:
            name = "Medium";
            break;
        case oC_GPIO_Current_Maximum:
            name = "Maximum";
            break;
        default:
            name = "Unknown";
            break;
    }
    free(&name, AllocationFlags_Default);
    return name;
}
const char * oC_GPIO_GetModeNameFromEnum(oC_GPIO_Mode_t Mode)
{
    char * name = malloc(sizeof(name)   , 10);

    switch(Mode)
    {
        case oC_GPIO_Mode_Default:
            name = "Default";
            break;
        case oC_GPIO_Mode_Input:
            name = "Input";
            break;
        case oC_GPIO_Mode_Output:
            name = "Output";
            break;
        case oC_GPIO_Mode_Alternate:
            name = "Alternate";
            break;
        default:
            name = "Unknown";
            break;
    }
    free(&name, AllocationFlags_Default);
    return name;
}
const char * oC_GPIO_GetOutputCircuitNameFromEnum(oC_GPIO_OutputCircuit_t OutputCircuit)
{
    char * name = malloc(sizeof(name)   , 10);

    switch(OutputCircuit)
    {
        case oC_GPIO_OutputCircuit_Default:
            name = "Default";
            break;
        case oC_GPIO_OutputCircuit_OpenDrain:
            name = "OpenDrain";
            break;
        case oC_GPIO_OutputCircuit_PushPull:
            name = "PushPull";
            break;
        default:
            name = "Unknown";
            break;
    }

    free(&name, AllocationFlags_Default);
    return name;
}

const char * oC_GPIO_GetPullNameFromEnum(oC_GPIO_Pull_t Pull)
{
    char * name = malloc(sizeof(name)   , 10);

    switch(Pull)
    {
        case oC_GPIO_Pull_Default:
            name = "Default";
            break;
        case oC_GPIO_Pull_Down:
            name = "Down";
            break;
        case oC_GPIO_Pull_Up:
            name = "Up";
            break;
        default:
            name = "Unknown";
            break;
    }

    free(&name, AllocationFlags_Default);
    return name;
}

const char * oC_GPIO_GetSpeedNameFromEnum(oC_GPIO_Speed_t Speed)
{
    char * name = malloc(sizeof(name)   , 10);

    switch(Speed)
    {
        case oC_GPIO_Speed_Default:
            name = "Default";
            break;
        case oC_GPIO_Speed_Maximum:
            name = "Maximum";
            break;
        case oC_GPIO_Speed_Minimum:
            name = "Minimum";
            break;
        case oC_GPIO_Speed_Medium:
            name = "Medium";
            break;
        default:
            name = "Unknown";
            break;
    }

    free(&name, AllocationFlags_Default);
    return name;
}

const char * oC_GPIO_GetIntTriggerNameFromEnum(oC_GPIO_IntTrigger_t IntTrigger)
{
    char * name = malloc(sizeof(name)   , 6);

    switch(IntTrigger)
    {
        default:
        case oC_GPIO_IntTrigger_Off        :
            name = "Off";
            break;
        case oC_GPIO_IntTrigger_RisingEdge :
            name = "RisingEdge";
            break;
        case oC_GPIO_IntTrigger_FallingEdge:
            name = "FallingEdge";
            break;
        case oC_GPIO_IntTrigger_BothEdges  :
            name = "BothLevels";
            break;
        case oC_GPIO_IntTrigger_HighLevel  :
            name = "HighLevel";
            break;
        case oC_GPIO_IntTrigger_LowLevel   :
            name = "LowLevel";
            break;
        case oC_GPIO_IntTrigger_BothLevels :
            name = "BothLevels";
            break;
            name = "Unknown";
            break;
    }

    free(&name, AllocationFlags_Default);
    return name;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_FindPinByName( const char * Name , oC_Pin_t * outPin )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        if(
            ErrorCondition(isram(outPin)          , oC_ErrorCode_OutputAddressNotInRAM) &&
            ErrorCondition(isaddresscorrect(Name) , oC_ErrorCode_WrongAddress)
            )
        {
            errorCode = oC_ErrorCode_PinNotDefined;

            oC_Pin_ForeachDefined(pin)
            {
                if(strcmp(pin->Name,Name) == 0)
                {
                    *outPin   = pin->Pin;
                    errorCode = oC_ErrorCode_None;
                }
            }
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_GPIO_WaitForPins( oC_Pins_t Pins , oC_Time_t Timeout )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode , oC_Module_GPIO))
    {
        if(oC_Event_WaitForState(InterruptEvent , Pins , oC_GPIO_LLD_GetImportantBitsMaskForPins(Pins) , Timeout))
        {
            oC_Event_ClearStateBits(InterruptEvent , oC_GPIO_LLD_GetPinsMaskOfPins(Pins));
            errorCode = oC_ErrorCode_None;
        }
        else
        {
            errorCode = oC_ErrorCode_TimeoutError;
        }
    }

    return errorCode;
}

#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

#define _________________________________________INTERRUPTS_SECTION_________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
static void InterruptHandler( oC_Pins_t Pins )
{
    oC_Event_SetState(InterruptEvent,Pins);
}

#undef  _________________________________________INTERRUPTS_SECTION_________________________________________________________________________