oc_pins.h

Go to the documentation of this file.

#ifndef SYSTEM_PORTABLE_INC_OC_PINS_H_
#define SYSTEM_PORTABLE_INC_OC_PINS_H_

#include <oc_1word.h>
#include <oc_pins_defs.h>
#include <oc_channels.h>
#include <oc_ba.h>
#include <oc_bits.h>
#include <oc_pinsmap.h>
#include <oc_array.h>

#if !oC_Channel_IsModuleDefined(GPIO)
#error GPIO module is not defined
#else

#define _________________________________________MACROS_SECTION_____________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_IsModuleDefined(MODULE_NAME)                      defined(oC_MODULE_PINS_##MODULE_NAME)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePinFunctions_IsModuleDefined(MODULE_NAME)             defined(oC_MODULE_PIN_FUNCTIONS_##MODULE_NAME)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_(PIN_NAME,...)                                           oC_1WORD_FROM_2(oC_Pin_ , PIN_NAME)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_PinIndex_(PIN_NAME,...)                                      oC_1WORD_FROM_2(oC_PinIndex_ , PIN_NAME)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePinIndex_(CHANNEL_NAME,PIN_FUNCTION,PIN_NAME,DIGITAL_VALUE)    oC_1WORD_FROM_8( oC_ModulePinIndex_ , CHANNEL_NAME , _ , PIN_FUNCTION , _ , PIN_NAME , _ , DIGITAL_VALUE )

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_PinFunctionIndex_(PIN_FUNCTION)                              oC_1WORD_FROM_2(oC_PinFunctionIndex_ , PIN_FUNCTION)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePinFunction_(MODULE_NAME,PIN_FUNCTION)                 oC_1WORD_FROM_4(oC_,MODULE_NAME,_PinFunction_ , PIN_FUNCTION )
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_(MODULE_NAME,CHANNEL_NAME,PIN_FUNCTION,PIN_NAME,DIGITAL_VALUE)       oC_1WORD_FROM_8(oC_ , MODULE_NAME, _Pin_ , CHANNEL_NAME , PIN_FUNCTION,PIN_NAME,_,DIGITAL_VALUE)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePinType_(MODULE_NAME)                                  oC_1WORD_FROM_3(oC_,MODULE_NAME,_Pin_t)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_PinsInPortMask                                   ( (1<<(oC_PORT_WIDTH))                  - 1 )
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_PinFunctionMask                                  ( (1<<(oC_MODULE_PIN_FUNCTION_WIDTH))    - 1 )

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_PinAlternateNumberMask                           ( (1<<(oC_ALTERNATE_NUMBER_FIELD_WIDTH)) - 1 )

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_PinsInPortMaskWidth                          (oC_PORT_WIDTH)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_ChannelMaskWidth                             (oC_CHANNEL_MASK_WIDTH)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_MaskWidth                                    ((oC_Pin_PinsInPortMaskWidth) + (oC_Pin_ChannelMaskWidth))

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_PinsInPortMaskStartBit                       (0)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_ChannelMaskStartBit                          ((oC_Pin_PinsInPortMaskWidth) + (oC_Pin_PinsInPortMaskStartBit))
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_PinsInPortMask                               ((oC_PinsInPortMask)    << (oC_Pin_PinsInPortMaskStartBit))
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_ChannelMask                                  ((oC_ChannelMask)       << (oC_Pin_ChannelMaskStartBit) )
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_Mask                                         ( (1<<(oC_Pin_MaskWidth)) - 1 )
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Make_PinFunctionsForModule(MODULE_NAME)          oC_MODULE_PIN_FUNCTIONS_(MODULE_NAME)(MAKE_PIN_FUNCTION)
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Make_PinFunctionForModule(PIN_FUNCTION,...)      oC_ModulePinFunction_(MODULE_NAME,PIN_FUNCTION) = oC_PinFunctionIndex_(PIN_FUNCTION) ,
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Make_ModulePinForModule( PIN_NAME , CHANNEL_NAME  , PIN_FUNCTION   , ALTERNATE_FUNCTION , ... ) \
    oC_ModulePin_(MODULE_NAME,CHANNEL_NAME,PIN_FUNCTION,PIN_NAME,ALTERNATE_FUNCTION) = oC_ModulePinIndex_(CHANNEL_NAME,PIN_FUNCTION,PIN_NAME,ALTERNATE_FUNCTION),

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_GetPinsInPort(Pin)                           ( ((Pin) & (oC_Pin_PinsInPortMask)) >> oC_Pin_PinsInPortMaskStartBit )
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_GetChannel(Pin)                              ( ((Pin) & (oC_Pin_ChannelMask))    >> oC_Pin_ChannelMaskStartBit )

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_GetPort(Pin)                                 oC_Pin_GetChannel(Pin)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_Make(Port,PinsInPort)                            \
    oC_Bits_ValueWithMask( PinsInPort , oC_Pin_PinsInPortMaskStartBit,  oC_Pin_PinsInPortMask) |  \
    oC_Bits_ValueWithMask( Port       , oC_Pin_ChannelMaskStartBit,     oC_Pin_ChannelMask)    \


//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pins_ToSinglePin(Pins,PinIndex)                       ( ((Pins) & ((1<<PinIndex)<<oC_Pin_PinsInPortMaskStartBit)) | ((Pins) & oC_Pin_ChannelMask) )

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_GetData(ModulePin)                          (&oC_ModulePinsData[ModulePin])
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_GetPin(ModulePin)                              oC_ModulePin_GetData(ModulePin)->Pin
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_GetPinFunction(ModulePin)                      oC_ModulePin_GetData(ModulePin)->PinFunction
//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_GetChannel(ModulePin)                          oC_ModulePin_GetData(ModulePin)->Channel

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_GetAlternateNumber(ModulePin)                  oC_ModulePin_GetData(ModulePin)->AlternateNumber

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePinFunction_DefineType     \
    typedef enum \
    { \
        oC_MODULE_PIN_FUNCTIONS_(MODULE_NAME)(oC_Make_PinFunctionForModule) \
        oC_Make_PinFunctionForModule(NumberOfElements)\
    } oC_ModulePinFunction_(MODULE_NAME,t)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_DefineType       \
    typedef enum    \
    { \
        oC_MODULE_PINS_(MODULE_NAME)(oC_Make_ModulePinForModule) \
    } oC_ModulePinType_(MODULE_NAME)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Pin_ForeachDefined(PinVariableName)          oC_ARRAY_FOREACH_IN_ARRAY(oC_DefinedPins , PinVariableName)

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_ModulePin_ForeachDefined(PinVariableName)    oC_ARRAY_FOREACH_IN_ARRAY(oC_ModulePinsData , PinVariableName)

#undef  _________________________________________MACROS_SECTION_____________________________________________________________________________

#define _________________________________________TYPES_SECTION______________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Pin_NotUsed = 0 ,
#define MAKE_CFG_PIN(USER_PIN_NAME , PIN_NAME)      oC_Pin_(USER_PIN_NAME) = oC_Pin_(PIN_NAME) ,
#define MAKE_PIN(BASE_ADDRESS_NAME , PIN_NAME , BIT_INDEX , PIN_NUMBER) \
    oC_Pin_(PIN_NAME) = oC_Pin_Make(oC_Channel_(BASE_ADDRESS_NAME) , 1 << BIT_INDEX) ,

    oC_PINS_LIST(MAKE_PIN)
    oC_CFG_PINS(MAKE_CFG_PIN)
#undef MAKE_PIN
#undef MAKE_CFG_PIN
} oC_Pin_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
#define MAKE_PIN(BASE_ADDRESS_NAME , PIN_NAME , BIT_INDEX , PIN_NUMBER) \
    oC_PinIndex_(PIN_NAME) ,
    oC_PINS_LIST(MAKE_PIN)
    oC_PinIndex_NumberOfElements
#undef MAKE_PIN
} oC_PinIndex_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
#define MAKE_MODULE_PIN( PIN_NAME , CHANNEL_NAME  , PIN_FUNCTION   , ALTERNATE_FUNCTION )       \
                oC_ModulePinIndex_(CHANNEL_NAME,PIN_FUNCTION,PIN_NAME,ALTERNATE_FUNCTION) ,
#define MAKE_MODULE(MODULE_NAME)            oC_MODULE_PINS_(MODULE_NAME)(MAKE_MODULE_PIN)
    oC_MODULES_PINS_LIST(MAKE_MODULE)
#undef MAKE_MODULE
#undef MAKE_MODULE_PIN
    oC_ModulePinIndex_NumberOfElements
} oC_ModulePinIndex_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
#define MAKE_MODULE_PIN_FUNCTION( PIN_FUNCTION )       \
                oC_PinFunctionIndex_(PIN_FUNCTION) ,
#define MAKE_MODULE(MODULE_NAME)            oC_MODULE_PIN_FUNCTIONS_(MODULE_NAME)(MAKE_MODULE_PIN_FUNCTION)
    oC_MODULES_PINS_LIST(MAKE_MODULE)
#undef MAKE_MODULE
#undef MAKE_MODULE_PIN_FUNCTION
    oC_PinFunctionIndex_NumberOfElements
} oC_PinFunctionIndex_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef oC_Pin_t oC_Pins_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef oC_Channel_t oC_Port_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef oC_ChannelIndex_t oC_PortIndex_t;

#if oC_PORT_WIDTH <= 8
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint8_t oC_PinsInPort_t;
#elif oC_PORT_WIDTH <= 16
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint16_t oC_PinsInPort_t;
#elif oC_PORT_WIDTH <= 32
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint32_t oC_PinsInPort_t;
#elif oC_PORT_WIDTH <= 64
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint64_t oC_PinsInPort_t;
#else
#   error oC_PORT_WIDTH is too big! (max 64)
#endif

#if oC_ALTERNATE_NUMBER_FIELD_WIDTH <= 8
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint8_t oC_PinAlternateNumber_t;
#elif oC_ALTERNATE_NUMBER_FIELD_WIDTH <= 16
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint16_t oC_PinAlternateNumber_t;
#elif oC_ALTERNATE_NUMBER_FIELD_WIDTH <= 32
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint32_t oC_PinAlternateNumber_t;
#elif oC_ALTERNATE_NUMBER_FIELD_WIDTH <= 64
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint64_t oC_PinAlternateNumber_t;
#else
#   error oC_ALTERNATE_NUMBER_FIELD_WIDTH is too big! (max 64)
#endif

#if oC_MODULE_PIN_FUNCTION_WIDTH <= 8
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint8_t oC_PinFunction_t;
#elif oC_MODULE_PIN_FUNCTION_WIDTH <= 16
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint16_t oC_PinFunction_t;
#elif oC_MODULE_PIN_FUNCTION_WIDTH <= 32
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint32_t oC_PinFunction_t;
#elif oC_MODULE_PIN_FUNCTION_WIDTH <= 64
//==========================================================================================================================================
//==========================================================================================================================================
typedef uint64_t oC_PinFunction_t;
#else
#   error oC_MODULE_PIN_FUNCTION_WIDTH is too big! (max 64)
#endif

//==========================================================================================================================================
//==========================================================================================================================================
typedef oC_PinsInPort_t oC_PinsMask_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Pin_t        Pin;        
    const char *    Name;       
} oC_DefinedPinData_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Pin_t                    Pin;                
    oC_PinAlternateNumber_t     AlternateNumber;    
    oC_Channel_t                Channel;            
    oC_PinFunction_t            PinFunction;        
    oC_ModulePinIndex_t         ModulePinIndex;     
} oC_ModulePinData_t;

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________VARIABLES_SECTION__________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
extern const oC_DefinedPinData_t oC_DefinedPins[oC_PinIndex_NumberOfElements];

//==========================================================================================================================================
//==========================================================================================================================================
extern const oC_ModulePinData_t oC_ModulePinsData[oC_ModulePinIndex_NumberOfElements];

#undef  _________________________________________VARIABLES_SECTION__________________________________________________________________________


#endif /* SYSTEM_PORTABLE_INC_OC_PINS_H_ */
#endif