Bfx_16bits.h

Go to the documentation of this file.

#include "Std_Types.h"

#define MAX_VALUE         32767  
#define MIN_VALUE         -32768 
#define MAX_VALUE_USIGNED 0xFFFF 

static inline void Bfx_SetBit_u16u8( uint16 *Data, uint8 BitPn )
{
    *Data |= ( 0x01 << BitPn );
}

static inline void Bfx_ClrBit_u16u8( uint16 *Data, uint8 BitPn )
{
    *Data &= ~( 0x01 << BitPn );
}

static inline boolean Bfx_GetBit_u16u8_u8( uint16 Data, uint8 BitPn )
{
    boolean Result;
 
    Result = ( Data >> BitPn ) & 1u;
    return Result;
}

static inline void Bfx_SetBits_u16u8u8u8( uint16 *Data, uint8 BitStartPn, uint8 BitLn, uint8 Status )
{
    uint16 Mask = ( ( 1u << BitLn ) - 1 ) << BitStartPn;
 
    if( Status == 0 )
    {
        *Data &= ~Mask;
    }
    else if( Status == 1 )
    {
        *Data |= Mask;
    }
}

static inline uint8 Bfx_GetBits_u16u8u8_u16( uint16 Data, uint8 BitStartPn, uint8 BitLn )
{
    uint16 Result;
 
    Result = ( Data >> BitStartPn ) & ( ( 1u << BitLn ) - 1u );
    return Result;
}

static inline void Bfx_SetBitMask_u16u16( uint16 *Data, uint16 Mask )
{
    *Data |= Mask;
}

static inline void Bfx_ClrBitMask_u16u16( uint16 *Data, uint16 Mask )
{
    *Data &= ~Mask;
}

static inline boolean Bfx_TstBitMask_u16u16_u8( uint16 Data, uint16 Mask )
{
    boolean Result;
 
    Result = ( Data & Mask ) == Mask;
    return Result;
}

static inline boolean Bfx_TstBitLnMask_u16u16_u8( uint16 Data, uint16 Mask )
{
    boolean Result;
 
    Result = ( Data & Mask ) > 0;
    return Result;
}

static inline boolean Bfx_TstParityEven_u16_u8( uint16 Data )
{
    boolean parity = FALSE;
    boolean Result;
 
    while( Data > 0 )
    {
        parity = !parity;
        Data &= ( Data - 1 );
    }
    Result = !parity;
    return Result;
}

static inline void Bfx_ToggleBits_u16( uint16 *Data )
{
    *Data = ~*Data;
}

static inline void Bfx_ToggleBitMask_u16u16( uint16 *Data, uint16 Mask )
{
    *Data ^= Mask;
}

static inline void Bfx_ShiftBitRt_u16u8( uint16 *Data, uint8 ShiftCnt )
{
    *Data >>= ShiftCnt;
}

static inline void Bfx_ShiftBitLt_u16u8( uint16 *Data, uint8 ShiftCnt )
{
    *Data <<= ShiftCnt;
}

static inline void Bfx_RotBitRt_u16u8( uint16 *Data, uint8 ShiftCnt )
{
    *Data = ( *Data >> ShiftCnt ) | ( *Data << ( 16 - ShiftCnt ) );
}

static inline void Bfx_RotBitLt_u16u8( uint16 *Data, uint8 ShiftCnt )
{
    *Data = ( *Data << ShiftCnt ) | ( *Data >> ( 16 - ShiftCnt ) );
}

static inline void Bfx_CopyBit_u16u8u16u8( uint16 *DestinationData, uint8 DestinationPosition, uint16 SourceData, uint8 SourcePosition )
{
    boolean Buffer;
 
    Buffer = ( ( SourceData & ( 0x01 << SourcePosition ) ) != 0 ) ? TRUE : FALSE;
    if( Buffer == FALSE )
    {
        *DestinationData = ( *DestinationData & ~( 0x01 << DestinationPosition ) );
    }
    else
    {
        *DestinationData = *DestinationData | ( 0x01 << DestinationPosition );
    }
}

static inline void Bfx_PutBits_u16u8u8u16( uint16 *Data, uint8 BitStartPn, uint8 BitLn, uint16 Pattern )
{
    uint16 Mask = ( ( 1u << BitLn ) - 1u ) << BitStartPn;
    *Data       = ( *Data & ~Mask ) | ( ( Pattern << BitStartPn ) & Mask );
}

static inline void Bfx_PutBitsMask_u16u16u16( uint16 *Data, uint16 Pattern, uint16 Mask )
{
    *Data = ( *Data & ~Mask ) | ( Pattern & Mask );
}

static inline void Bfx_PutBit_u16u8u8( uint16 *Data, uint8 BitPn, boolean Status )
{
    if( Status == FALSE )
    {
        *Data &= ~( 0x01 << BitPn );
    }
    else
    {
        *Data |= 0x01 << BitPn;
    }
}

static inline uint8 Bfx_CountLeadingOnes_u16( uint16 Data )
{
    uint8 Counter = 0;
 
    for( uint8 i = 16; i > 0; i-- )
    {
        if( ( Data & ( 0x01 << ( i - 1 ) ) ) != 0 )
        {
            Counter++;
        }
        else
        {
            i = 1;
        }
    }
    return Counter;
}

static inline uint8 Bfx_CountLeadingZeros_u16( uint16 Data )
{
    uint8 Counter = 0;
 
    for( uint8 i = 16; i > 0; i-- )
    {
        if( ( Data & ( 0x01 << ( i - 1 ) ) ) != 0 )
        {
            i = 1;
        }
        else
        {
            Counter++;
        }
    }
    return Counter;
}

static inline uint8 Bfx_CountLeadingSigns_s16( sint16 Data )
{
    uint8 Count = 0;
    sint16 Mask = 32767;
 
    if( Data >= 0 )
    {
        while( ( Data & Mask ) == 0 )
        {
            Count++;
            Mask >>= 1;
        }
    }
    else
    {
        while( ( Data & Mask ) == Mask )
        {
            Count++;
            Mask >>= 1;
        }
    }
    Data = Count - 1;
    return Data;
}

static inline sint16 Bfx_ShiftBitSat_s16s8_s16( sint8 ShiftCnt, sint16 Data )
{
    uint16 Mask            = 0x8000;
    boolean DataIsNegative = ( Data < 0 );
 
    if( ShiftCnt >= 0 )
    {
        Data <<= ShiftCnt;
        if( ( DataIsNegative == FALSE ) && ( Data < 0 ) )
        {
            Data = MAX_VALUE;
        }
        else if( ( DataIsNegative == TRUE ) && ( Data >= 0 ) )
        {
            Data = MIN_VALUE;
        }
    }
    else
    {
        ShiftCnt *= -1;
        if( Data > 0 )
        {
            Data >>= ShiftCnt;
        }
        else
        {
            Data >>= ShiftCnt;
            for( uint8 i = 0; i < ShiftCnt; i++ )
            {
                Data |= Mask;
                Mask >>= 1;
            }
        }
    }
    return Data;
}

static inline uint16 Bfx_ShiftBitSat_u16s8_u16( sint8 ShiftCnt, uint16 Data )
{
    uint16 Mask        = 0x8000;
    uint8 MaxShiftLeft = 0;
 
    while( ( Data & Mask ) == 0 )
    {
        MaxShiftLeft++;
        Mask >>= 1;
    }
    if( ShiftCnt >= 0 )
    {
        if( ShiftCnt > MaxShiftLeft )
        {
            Data = MAX_VALUE_USIGNED;
        }
        else
        {
            Data <<= ShiftCnt;
        }
    }
    else
    {
        ShiftCnt *= -1;
        Data >>= ShiftCnt;
    }
    return Data;
}