oc_bits.h

Go to the documentation of this file.

#ifndef SYSTEM_LIBRARIES_BITS_OC_BITS_H_
#define SYSTEM_LIBRARIES_BITS_OC_BITS_H_

#include <stdint.h>
#include <stdbool.h>

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Bits_Mask_U8( FROM , TO )   ((((((uint8_t)1)<<(TO)) - 1 ) | (((uint8_t)1)<<(TO))) ^ ((((uint8_t)1)<<(FROM)) - 1))

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Bits_Mask_U16( FROM , TO )   ((((((uint16_t)1)<<(TO)) - 1 ) | (((uint16_t)1)<<(TO))) ^ ((((uint16_t)1)<<(FROM)) - 1))

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Bits_Mask_U32( FROM , TO )   ((((((uint32_t)1)<<(TO)) - 1 ) | (((uint32_t)1)<<(TO))) ^ ((((uint32_t)1)<<(FROM)) - 1))

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Bits_Mask_U64( FROM , TO )   ((((((uint64_t)1)<<(TO)) - 1 ) | (((uint64_t)1)<<(TO))) ^ ((((uint64_t)1)<<(FROM)) - 1))

//==========================================================================================================================================
//==========================================================================================================================================
#define oC_Bits_ValueWithMask(VALUE,FROM,MASK)      ( ((VALUE) << (FROM)) & (MASK) )

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint8_t  oC_Bits_SetBitsU8(  uint8_t  * outVariable , uint8_t  Mask )
{
    *outVariable |= Mask;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_SetBitsU16( uint16_t * outVariable , uint16_t Mask )
{
    *outVariable |= Mask;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_SetBitsU32( uint32_t * outVariable , uint32_t Mask )
{
    *outVariable |= Mask;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_SetBitsU64( uint64_t * outVariable , uint64_t Mask )
{
    *outVariable |= Mask;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint8_t  oC_Bits_ClearBitsU8(  uint8_t  * outVariable , uint8_t  Mask )
{
    *outVariable &= ( ~Mask );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_ClearBitsU16( uint16_t * outVariable , uint16_t Mask )
{
    *outVariable &= ( ~Mask );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_ClearBitsU32( uint32_t * outVariable , uint32_t Mask )
{
    *outVariable &= ( ~Mask );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_ClearBitsU64( uint64_t * outVariable , uint64_t Mask )
{
    *outVariable &= ( ~Mask );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint8_t  oC_Bits_SetValueU8(  uint8_t  * outVariable , uint8_t  Value , uint8_t StartBitNr , uint8_t EndBitNr)
{
    *outVariable = ( *outVariable & ( ~oC_Bits_Mask_U8 ( StartBitNr , EndBitNr ))) | ((Value<<StartBitNr) & oC_Bits_Mask_U8 ( StartBitNr , EndBitNr ));
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_SetValueU16( uint16_t * outVariable , uint16_t Value , uint8_t StartBitNr , uint8_t EndBitNr)
{
    *outVariable = ( *outVariable & ( ~oC_Bits_Mask_U16 ( StartBitNr , EndBitNr ))) | ((Value<<StartBitNr) & oC_Bits_Mask_U16 ( StartBitNr , EndBitNr ));
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_SetValueU32( uint32_t * outVariable , uint32_t Value , uint8_t StartBitNr , uint8_t EndBitNr)
{
    *outVariable = ( *outVariable & ( ~oC_Bits_Mask_U32 ( StartBitNr , EndBitNr ))) | ((Value<<StartBitNr) & oC_Bits_Mask_U32 ( StartBitNr , EndBitNr ));
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_SetValueU64( uint64_t * outVariable , uint64_t Value , uint8_t StartBitNr , uint8_t EndBitNr)
{
    *outVariable = ( *outVariable & ( ~oC_Bits_Mask_U64 ( StartBitNr , EndBitNr ))) | ((Value<<StartBitNr) & oC_Bits_Mask_U64 ( StartBitNr , EndBitNr ));
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint8_t oC_Bits_GetValueU8( uint8_t Variable , uint8_t StartBitNr , uint8_t EndBitNr )
{
    return (oC_Bits_Mask_U8 ( StartBitNr , EndBitNr ) & Variable)>>StartBitNr;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_GetValueU16( uint16_t Variable , uint8_t StartBitNr , uint8_t EndBitNr )
{
    return (oC_Bits_Mask_U16 ( StartBitNr , EndBitNr ) & Variable)>>StartBitNr;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_GetValueU32( uint32_t Variable , uint8_t StartBitNr , uint8_t EndBitNr )
{
    return (oC_Bits_Mask_U32 ( StartBitNr , EndBitNr ) & Variable)>>StartBitNr;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_GetValueU64( uint64_t Variable , uint8_t StartBitNr , uint8_t EndBitNr )
{
    return (oC_Bits_Mask_U64 ( StartBitNr , EndBitNr ) & Variable)>>StartBitNr;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Bits_SplitU64ToU32( uint64_t Variable , uint32_t * outLow , uint32_t * outHigh )
{
    *outLow = (uint32_t)Variable;
    *outHigh = (uint32_t)(Variable>>32);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Bits_SplitU32ToU16( uint32_t Variable , uint16_t * outLow , uint16_t * outHigh )
{
    *outLow = (uint16_t)Variable;
    *outHigh = (uint16_t)(Variable>>16);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Bits_SplitU16ToU8( uint16_t Variable , uint8_t * outLow , uint8_t * outHigh )
{
    *outLow = (uint8_t)Variable;
    *outHigh = (uint8_t)(Variable>>8);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_JoinU8ToU16( uint8_t LowPart , uint8_t HighPart )
{
    return (((uint16_t)HighPart)<<8)|((uint16_t)LowPart);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_JoinU16ToU32( uint16_t LowPart , uint16_t HighPart )
{
    return (((uint32_t)HighPart)<<16)|((uint32_t)LowPart);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_JoinU32ToU64( uint32_t LowPart , uint32_t HighPart )
{
    return (((uint64_t)HighPart)<<32)|((uint64_t)LowPart);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline int8_t oC_Bits_GetBitNumberU8( uint8_t BitMask )
{
    int8_t i;
    int8_t ret = -1;
    for (i = 0; i < 8; i++)
    {
        if ((BitMask & 0x01) == 0x01)
        {
            ret = i;
            break;
        }
        else
        {
            BitMask = (BitMask >> 1);
        }
    }
    return ret;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline int8_t oC_Bits_GetBitNumberU16( uint16_t BitMask )
{
    int8_t i;
    int8_t ret = -1;
    for (i = 0; i < 16; i++)
    {
        if ((BitMask & 0x0001) == 0x0001)
        {
            ret = i;
            break;
        }
        else
        {
            BitMask = (BitMask >> 1);
        }
    }
    return ret;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline int8_t oC_Bits_GetBitNumberU32( uint32_t BitMask )
{
    int8_t i;
    int8_t ret = -1;
    for (i = 0; i < 32; i++)
    {
        if ((BitMask & 0x00000001) == 0x00000001)
        {
            ret = i;
            break;
        }
        else
        {
            BitMask = (BitMask >> 1);
        }
    }
    return ret;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline int8_t oC_Bits_GetBitNumberU64( uint64_t BitMask )
{
    int8_t i;
    int8_t ret = -1;
    for (i = 0; i < 64; i++)
    {
        if ((BitMask & 0x0000000000000001) == 0x0000000000000001)
        {
            ret = i;
            break;
        }
        else
        {
            BitMask = (BitMask >> 1);
        }
    }
    return ret;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsBitSetU8( uint8_t BitMask , uint8_t BitIndex )
{
    return (BitMask & (1<<BitIndex)) == (1<<BitIndex);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsBitSetU16( uint16_t BitMask , uint8_t BitIndex )
{
    return (BitMask & ((uint16_t)1<<BitIndex)) == ((uint16_t)1<<BitIndex);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsBitSetU32( uint32_t BitMask , uint8_t BitIndex )
{
    return (BitMask & ((uint32_t)1<<BitIndex)) == ((uint32_t)1<<BitIndex);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsBitSetU64( uint64_t BitMask , uint8_t BitIndex )
{
    return (BitMask & ((uint64_t)1<<BitIndex)) == ((uint64_t)1<<BitIndex);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint8_t  oC_Bits_SetBitU8(  uint8_t  * outVariable , uint8_t  BitIndex )
{
    *outVariable |= (uint8_t)1<<BitIndex;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_SetBitU16( uint16_t * outVariable , uint8_t BitIndex )
{
    *outVariable |= (uint16_t)1<<BitIndex;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_SetBitU32( uint32_t * outVariable , uint8_t BitIndex )
{
    *outVariable |= (uint32_t)1<<BitIndex;
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_SetBitU64( uint64_t * outVariable , uint8_t BitIndex )
{
    *outVariable |= (uint64_t)1<<BitIndex;
    return *outVariable;
}


//==========================================================================================================================================
//==========================================================================================================================================
static inline uint8_t  oC_Bits_ClearBitU8(  uint8_t  * outVariable , uint8_t  BitIndex )
{
    *outVariable &= ~((uint8_t)1<<BitIndex );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Bits_ClearBitU16( uint16_t * outVariable , uint8_t  BitIndex )
{
    *outVariable &= ~((uint16_t)1<<BitIndex );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Bits_ClearBitU32( uint32_t * outVariable , uint8_t  BitIndex )
{
    *outVariable &= ~((uint32_t)1<<BitIndex );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint64_t oC_Bits_ClearBitU64( uint64_t * outVariable , uint8_t  BitIndex )
{
    *outVariable &= ~((uint64_t)1<<BitIndex );
    return *outVariable;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsSetU8( uint8_t BitMask , uint8_t  BitsToCheck )
{
    return (BitMask & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsSetU16( uint16_t BitMask , uint16_t  BitsToCheck )
{
    return (BitMask & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsSetU32( uint32_t BitMask , uint32_t  BitsToCheck )
{
    return (BitMask & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsSetU64( uint64_t BitMask , uint64_t  BitsToCheck )
{
    return (BitMask & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsClearU8( uint8_t BitMask , uint8_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsClearU16( uint16_t BitMask , uint16_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsClearU32( uint32_t BitMask , uint32_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_AreBitsClearU64( uint64_t BitMask , uint64_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck) == BitsToCheck;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitSetU8( uint8_t BitMask , uint8_t  BitsToCheck )
{
    return (BitMask & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitSetU16( uint16_t BitMask , uint16_t  BitsToCheck )
{
    return (BitMask & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitSetU32( uint32_t BitMask , uint32_t  BitsToCheck )
{
    return (BitMask & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitSetU64( uint64_t BitMask , uint64_t  BitsToCheck )
{
    return (BitMask & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitClearU8( uint8_t BitMask , uint8_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitClearU16( uint16_t BitMask , uint16_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitClearU32( uint32_t BitMask , uint32_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Bits_IsAtLeastOneBitClearU64( uint64_t BitMask , uint64_t  BitsToCheck )
{
    return ((~BitMask) & BitsToCheck);
}

#endif /* SYSTEM_LIBRARIES_BITS_OC_BITS_H_ */