Anvilex_Library.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//! @file       Anvilex_Library.h
//! @brief      Anvilex library header file.
//! @copyright  (C) 2004-2020 ANVILEX LLC
//! @attention  No special attention requered.
//!             $HeadURL: https://192.168.3.4:8443/svn/P004_07/ConOpSys/Common/Anvilex_Library.h $
//!             $Revision: 2765 $
//!             $Date: 2021-07-04 04:32:25 +0500 (So, 04 Jul 2021) $
//!             $Author: minch $
//------------------------------------------------------------------------------
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of ANVILEX nor the names of its contributors may be
//    used to endorse or promote products derived from this software without
//    specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// Protecting header files from mutual, recursive inclusion.
//------------------------------------------------------------------------------
 
#pragma once
 
//------------------------------------------------------------------------------
// system includes
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// project includes
//------------------------------------------------------------------------------
 
#include "Defines.h"
 
//------------------------------------------------------------------------------
// Export function prototypes
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//! @brief     Decode hex string to 8 bit unsigned integer representation
//! @note      None
//! @param     [in] *c8_Input_Buffer Pointer to input hex string
//! @param     [out] *u8_Output_Buffer Pointer to the output buffer
//! @param     [in] u16_Input_Size Length of input hex string
//! @param     [in] u16_Output_Size Size of the output buffer
//! @return    Convertion status
//! @retval    false - Convertion failed
//! @retval    true - Convertion successed
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Decode_Hex_Buffer( C8 *c8_Input_Buffer, U8* u8_Output_Buffer, U16 u16_Input_Size, U16 u16_Output_Size );
 
//------------------------------------------------------------------------------
//! @brief     Check input string for integer representation
//! @note      None
//! @param     [in] *c8_Input_String Input string
//! @return    Checking status
//! @retval    false - String don't have an integer value representation
//! @retval    true - String have an integer value representation
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Is_Integer( C8 *c8_Input_String );
 
//------------------------------------------------------------------------------
//! @brief     Check input string for floating point representation
//! @note      None
//! @param     [in] *c8_Input_String Input string
//! @return    Checking status
//! @retval    false - String don't have a floating point value representation
//! @retval    true - String have a floating point value representation
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Is_Float( C8 *c8_Input_String );
 
//------------------------------------------------------------------------------
//! @brief     Check input string for hexadecimal representation
//! @note      None
//! @param     [in] *c8_Input_String Input string
//! @return    Checking status
//! @retval    false - String don't have a hexadecimal value representation
//! @retval    true - String have a hexadecimal value representation
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Is_Hex( C8 *c8_Input_String );
 
//------------------------------------------------------------------------------
//! @brief     Check for input 32-bit unsigned value is odd
//! @note      None
//! @param     [in] *u32_Value Input 32-bit unsigned value
//! @return    Checking status
//! @retval    false - 32 bit unsigned value is not odd
//! @retval    true - 32 bit unsigned value is odd
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Is_Odd( U32 u32_Value );
 
//------------------------------------------------------------------------------
//! @brief     Check for input 32-bit unsigned value is even
//! @note      None
//! @param     [in] *u32_Value Input 32-bit unsigned value
//! @return    Checking status
//! @retval    false - 32 bit unsigned value is not even
//! @retval    true - 32 bit unsigned value is even
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Is_Even( U32 u32_Value );
 
//extern unsigned char Swap_Bit_Direction( unsigned char value );
//extern unsigned short Swap_Bit_Direction( unsigned short value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 8 bit unsigned integer (U8) to 7-segment indicator code (S7)
//! @note      None
//! @param     [in] u8_Input_Value Input 8-bit unsigned integer value
//! @param     [out] *s7_Output_Value Pointer to 7-segment indicator code
//! @return    Conversion status
//! @retval    false - Conversion failed
//! @retval    true - Conversion successed
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Convert_U8_To_S7( U8 u8_Input_Value, S7 *s7_Output_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 8 bit chaaracter (C8) to 7-segment indicator code (S7)
//! @note      None
//! @param     [in] c8_Input_Value Input 8-bit character code
//! @param     [out] *s7_Output_Value Pointer to 7-segment indicator code
//! @return    Conversion status
//! @retval    false - Conversion failed
//! @retval    true - Conversion successed
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Convert_C8_To_S7( C8 c8_Input_Value, S7 *s7_Output_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 8 bit character (C8) to 7-segment indicator code (S7) and insert decomal point information
//! @note      None
//! @param     [in] c8_Input_Value Input 8-bit character code
//! @param     [in] bool_Decimal_Point Decomal point status
//! @param     [out] *s7_Output_Value Pointer to 7-segment indicator code
//! @return    Conversion status
//! @retval    false - Conversion failed
//! @retval    true - Conversion successed
//! @attention None
//------------------------------------------------------------------------------
 
extern BOOL Convert_C8_To_S7( C8 c8_Input_Value, BOOL bool_Decimal_Point, S7 *s7_Output_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 16 bit unsigned integer (U16) to 7-segment indicator code (S7) string
//! @note      None
//! @param     [in] u16_Input_Value Input 16-bit unsigned integer value
//! @param     [out] *s7_Output_String Pointer to string of 7-segment indicator codes
//! @return    None
//! @attention None
//------------------------------------------------------------------------------
 
extern VOID Convert_U16_To_S7_String( U16 u16_Input_Value, S7 *s7_Output_String );
 
//------------------------------------------------------------------------------
//! @brief     Convert 8 bit-unsigned integer value (U8) to two digit BCD2 code (U8)
//! @note      None
//! @param     [in] u8_Value Input 8-bit unsigned integer value
//! @return    Two digit BCD code
//! @attention Input value not checked for valid range
//------------------------------------------------------------------------------
 
extern U8 Byte_To_BCD2( U8 u8_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert two digit BCD2 code (U8) to 8-bit unsigned integer value (U8)
//! @note      None
//! @param     [in] u8_Value Input two digit BCD2 code value
//! @return    Two digit BCD code
//! @attention Input value not checked for valid range
//------------------------------------------------------------------------------
 
extern U8 BCD2_To_Byte( U8 u8_Value );
 
//------------------------------------------------------------------------------
 
extern U8 Hex_To_U8( C8 c8_Value );
 
//------------------------------------------------------------------------------
 
extern C8 Low_Nibble_To_Hex( U8 u8_Value );
 
//------------------------------------------------------------------------------
 
extern C8 High_Nibble_To_Hex( U8 u8_Value );
 
//------------------------------------------------------------------------------
// Bit swaping functions
//------------------------------------------------------------------------------
 
extern U8 Bit_Swap( U8 u8_Value ); //!< Bit swaping
 
//------------------------------------------------------------------------------
 
extern U16 Swap_Bytes_U16( U16 u16_Value );
 
//------------------------------------------------------------------------------
 
extern U32 Swap_Bytes_U32( U32 u16_Value );
 
//------------------------------------------------------------------------------
 
extern U64 Swap_Bytes_U64( U64 u64_Value );
 
//------------------------------------------------------------------------------
 
extern BOOL Is_Bit_Set( U16 u16_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
// Cross data type conversion with saturation
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//! @brief     Convert 32-bit unsigned integer number (U32) to 16-bit unsigned indeger number (U16) with saturation at the bounds of datatype.
//! @note      None
//! @param     [in] u32_Input_Value Input 32-bit unsigned integer value
//! @return    Result of convertion as unsigned integer number (U16)
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 Convert_U32_To_U16_Satureted( U32 u32_Input_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 64-bit unsigned integer number (U64) to 16-bit unsigned indeger number (U16) with saturation at the bounds of datatype.
//! @note      None
//! @param     [in] u64_Input_Value Input 64-bit unsigned integer value
//! @return    Result of convertion as unsigned integer number (U16)
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 Convert_U64_To_U16_Satureted( U64 u64_Input_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 32-bit floating point number (F32) to 16-bit signed indeger number (I16) with saturation at the bounds of datatype.
//! @note      None
//! @param     [in] f32_Input_Value Input 32-bit floating point value
//! @return    Result of convertion as signed integer number (I16)
//! @attention None
//------------------------------------------------------------------------------
 
extern I16 Convert_F32_To_Saturated_I16( F32 f32_Input_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert 32 bit floating point number (F32) to 16 bit unsigned indeger number (U16) with saturation at the bounds of datatype.
//! @note      None
//! @param     [in] f32_Input_Value Input 32-bit floating point value
//! @return    Result of convertion as unsigned integer number (U16)
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 Convert_F32_To_Saturated_U16( F32 f32_Input_Value );
 
//------------------------------------------------------------------------------
// Composition functions
//------------------------------------------------------------------------------
 
extern VOID Split_U32( U32 u32_Input_Value, U16 *u16_Output_1, U16 *u16_Output_0 );
 
//------------------------------------------------------------------------------
//! @brief     Compose U16 value from U8 values.
//! @note      None
//! @param     [in] u8_Input_Byte_1 Input byte 1, bits 8 to 15.
//! @param     [in] u8_Input_Byte_0 Input byte 0, bits 0 to 7.
//! @return    Output U16 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 Compose_U16( U8 u8_Input_Byte_1, U8 u8_Input_Byte_0 );
 
//------------------------------------------------------------------------------
//! @brief     Compose U32 value from U8 values.
//! @note      None
//! @param     [in] u8_Input_Byte_3 Input byte 3, bits 24 to 31.
//! @param     [in] u8_Input_Byte_2 Input byte 2, bits 16 to 23.
//! @param     [in] u8_Input_Byte_1 Input byte 1, bits 8 to 15.
//! @param     [in] u8_Input_Byte_0 Input byte 0, bits 0 to 7.
//! @return    Output U32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U32 Compose_U32( U8 u8_Input_Byte_3, U8 u8_Input_Byte_2, U8 u8_Input_Byte_1, U8 u8_Input_Byte_0 );
 
//------------------------------------------------------------------------------
//! @brief     Compose U32 value from U16 values.
//! @note      None
//! @param     [in] u16_Input_1 Input word 1, bits 16 to 31.
//! @param     [in] u16_Input_0 Input word 0, bits 0 to 15.
//! @return    Output U32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U32 Compose_U32( U16 u16_Input_1, U16 u16_Input_0 );
 
//------------------------------------------------------------------------------
//! @brief     Compose U64 value from U16 values.
//! @note      None
//! @param     [in] u16_Input_3 Input word 3, bits 48 to 63.
//! @param     [in] u16_Input_2 Input word 2, bits 32 to 47.
//! @param     [in] u16_Input_1 Input word 1, bits 16 to 31.
//! @param     [in] u16_Input_0 Input word 0, bits 0 to 15.
//! @return    Output U64 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U64 Compose_U64( U16 u16_Input_3, U16 u16_Input_2, U16 u16_Input_1, U16 u16_Input_0 );
 
//------------------------------------------------------------------------------
//! @brief     Compose U64 value from U32 values.
//! @note      None
//! @param     [in] u32_Input_1 Input word 1, bits 32 to 63.
//! @param     [in] u32_Input_0 Input word 0, bits 0 to 31.
//! @return    Output U64 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U64 Compose_U64( U32 u32_Input_1, U32 u32_Input_0 );
 
//------------------------------------------------------------------------------
//! @brief     Compose F32 value from U8 values.
//! @note      None
//! @param     [in] u8_Input_Byte_3 Input byte 3, bits 24 to 31.
//! @param     [in] u8_Input_Byte_2 Input byte 2, bits 16 to 23.
//! @param     [in] u8_Input_Byte_1 Input byte 1, bits 8 to 15.
//! @param     [in] u8_Input_Byte_0 Input byte 0, bits 0 to 7.
//! @return    Output F32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern F32 Compose_F32( U8 u8_Input_Byte_3, U8 u8_Input_Byte_2, U8 u8_Input_Byte_1, U8 u8_Input_Byte_0 );
 
//------------------------------------------------------------------------------
// Extraction functions
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//! @brief     Extract U8 value from U16 value.
//! @note      None
//! @param     [in] u16_Value Input U16 value.
//! @param     [in] u8_Index Byte index. Can be 0 for extracting bits 0 to 7, 1 for extracting bits 8 to 15.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Extract_U8_From_U16( U16 u16_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
//! @brief     Extract U8 value from U32 value.
//! @note      None
//! @param     [in] u32_Value Input U32 value.
//! @param     [in] u8_Index Byte index. Can be 0 for extracting bits 0 to 7, 1 for extracting bits 8 to 15, 2 for extracting bits 16 to 23, 3 for extracting bits 24 to 31.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Extract_U8_From_U32( U32 u32_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
//! @brief     Extract U16 value from U32 value.
//! @note      None
//! @param     [in] u32_Value Input U32 value.
//! @param     [in] u8_Index Word index. Can be 0 for extrecting bits 0 to 15 or 1 for extracting bits 16 to 31.
//! @return    Output U16 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 Extract_U16_From_U32( U32 u32_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
//! @brief     Extract U8 value from F32 value.
//! @note      None
//! @param     [in] f32_Value Input F32 value.
//! @param     [in] u8_Index Byte index. Can be 0 for extracting bits 0 to 7, 1 for extracting bits 8 to 15, 2 for extracting bits 16 to 23, 3 for extracting bits 24 to 31.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Extract_U8_From_F32( F32 f32_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
//! @brief     Extract U8 value from I8 value.
//! @note      None
//! @param     [in] i8_Value Input I8 value.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Extract_U8_From_I8( I8 i8_Value );
 
//------------------------------------------------------------------------------
//! @brief     Extract U8 value from I16 value.
//! @note      None
//! @param     [in] i16_Value Input I16 value.
//! @param     [in] u8_Index Byte index. Can be 0 for extracting bits 0 to 7, 1 for extracting bits 8 to 15.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Extract_U8_From_I16( I16 i16_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
//! @brief     Extract U8 value from I32 value.
//! @note      None
//! @param     [in] i32_Value Input I32 value.
//! @param     [in] u8_Index Byte index. Can be 0 for extracting bits 0 to 7, 1 for extracting bits 8 to 15, 2 for extracting bits 16 to 23, 3 for extracting bits 24 to 31.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Extract_U8_From_I32( I32 i32_Value, U8 u8_Index );
 
//------------------------------------------------------------------------------
// Increment variable with saturation related functions
//------------------------------------------------------------------------------
 
extern BOOL Increment_Saturated( U8 *u8_Value );
extern BOOL Increment_Saturated( U8 *u8_Value, U8 u8_Saturation );
 
extern BOOL Increment_Saturated( U16 *u16_Value );
extern BOOL Increment_Saturated( U16 *u16_Value, U16 u16_Saturation );
 
extern BOOL Increment_Saturated( U32 *u32_Value );
extern BOOL Increment_Saturated( U32 *u32_Value, U32 u32_Saturation );
 
extern BOOL Increment_Saturated( U64 *u64_Value );
extern BOOL Increment_Saturated( U64 *u64_Value, U64 u64_Saturation );
 
extern BOOL Increment_Saturated( F32 *f32_Value, F32 f32_Step, F32 f32_Saturation );
 
//------------------------------------------------------------------------------
// Decrement variable with saturation related functions
//------------------------------------------------------------------------------
 
extern BOOL Decrement_Saturated( U8 *u8_Value );
extern BOOL Decrement_Saturated( U8 *u8_Value, U8 u8_Saturation );
 
extern BOOL Decrement_Saturated( U16 *u16_Value );
extern BOOL Decrement_Saturated( U16 *u16_Value, U16 u16_Saturation );
 
extern BOOL Decrement_Saturated( U32 *u32_Value );
extern BOOL Decrement_Saturated( U32 *u32_Value, U32 u32_Saturation );
 
//extern BOOL Decrement_Saturated( U64 *u64_Value );
//extern BOOL Decrement_Saturated( U64 *u64_Value, U64 u64_Saturation );
 
extern BOOL Decrement_Saturated( F32 *f32_Value, F32 f32_Step, F32 f32_Saturation );
 
//------------------------------------------------------------------------------
// Increment variable with overflow related functions
//------------------------------------------------------------------------------
 
extern BOOL Increment_Overflowed( U8 *u8_Value, U8 u8_Maximal_Value );
 
//------------------------------------------------------------------------------
 
extern BOOL Increment_Overflowed( U16 *u16_Value, U16 u16_Maximal_Value );
 
//------------------------------------------------------------------------------
 
extern BOOL Increment_Overflowed( U32 *u32_Value, U32 u32_Maximal_Value );
 
//------------------------------------------------------------------------------
 
extern BOOL Increment_Overflowed( F32 *f32_Value, F32 f32_Step, F32 f32_Initial, F32 f32_Saturation );
 
//------------------------------------------------------------------------------
//! @brief     Return maximum value from two U8 values.
//! @note      None
//! @param     [in] u8_Value_1 First U8 value.
//! @param     [in] u8_Value_2 Second U8 value.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 Maximum_U8( U8 u8_Value_1, U8 u8_Value_2 );
 
//------------------------------------------------------------------------------
//! @brief     Return maximum value from two U16 values.
//! @note      None
//! @param     [in] u16_Value_1 First U16 value.
//! @param     [in] u16_Value_2 Second U16 value.
//! @return    Output U32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 Maximum_U16( U16 u16_Value_1, U16 u16_Value_2 );
 
//------------------------------------------------------------------------------
//! @brief     Return maximum value from two U32 values.
//! @note      None
//! @param     [in] u32_Value_1 First U32 value.
//! @param     [in] u32_Value_2 Second U32 value.
//! @return    Output U32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U32 Maximum_U32( U32 u32_Value_1, U32 u32_Value_2 );
 
//------------------------------------------------------------------------------
//! @brief     Return maximum value from two U64 values.
//! @note      None
//! @param     [in] u64_Value_1 First U64 value.
//! @param     [in] u64_Value_2 Second U64 value.
//! @return    Output U64 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U64 Maximum_U64( U64 u64_Value_1, U64 u64_Value_2 );
 
//------------------------------------------------------------------------------
 
extern BOOL Is_In_Range_Less_Greater( U16 u16_Value, U16 u16_Low_Bounds, U16 u16_High_Bounds );
 
//------------------------------------------------------------------------------
 
extern BOOL Is_In_Range_Less_Greater( U64 u64_Value, U64 u64_Low_Bounds, U64 u64_High_Bounds );
 
//------------------------------------------------------------------------------
 
extern BOOL Is_In_Range_Less_Greater( F32 f32_Value, F32 f32_Low_Bounds, F32 f32_High_Bounds );
 
//------------------------------------------------------------------------------
 
extern VOID Seconds_To_HMS( U32 u32_Time, U32 *u32_Hours, U32 *u32_Minutes, U32 *u32_Seconds );
 
//------------------------------------------------------------------------------
// Variable limitation
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//! @brief     Limit F32 value to lower or upper limit.
//! @note      None
//! @param     [in,out] f32_Value F32 value to limit.
//! @param     [in] f32_Lower_Limit Lower limit F32 value.
//! @param     [in] f32_Upper_Limit Upper limit F32 value.
//! @return    None
//! @attention None
//------------------------------------------------------------------------------
 
extern VOID Limit_Low_High_F32( F32 &f32_Value, F32 f32_Lower_Limit, F32 f32_Upper_Limit );
 
//------------------------------------------------------------------------------
//! @brief     Limit I32 value to lower or upper limit.
//! @note      None
//! @param     [in,out] i32_Value I32 value to limit.
//! @param     [in] i32_Lower_Limit Lower limit I32 value.
//! @param     [in] i32_Upper_Limit Upper limit I32 value.
//! @return    None
//! @attention None
//------------------------------------------------------------------------------
 
extern VOID Limit_Low_High_I32( I32 &i32_Value, I32 i32_Lower_Limit, I32 i32_Upper_Limit );
 
//------------------------------------------------------------------------------
//! @brief     Convert hexal string to U8 value.
//! @note      None
//! @param     [in] *c8_Value Pointer to null terminated hexal string.
//! @return    Output U8 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U8 String_To_U8( C8 *c8_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert hexal string to U16 value.
//! @note      None
//! @param     [in] *c8_Value Pointer to null terminated hexal string.
//! @return    Output U16 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U16 String_To_U16( C8 *c8_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert hexal string to U32 value.
//! @note      None
//! @param     [in] *c8_Value Pointer to null terminated hexal string.
//! @return    Output U32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U32 String_To_U32( C8 *c8_Value );
 
//------------------------------------------------------------------------------
//! @brief     Convert hexal string to U64 value.
//! @note      None
//! @param     [in] *c8_Value Pointer to null terminated hexal string.
//! @return    Output U64 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U64 String_To_U64( C8 *c8_Value );
 
//------------------------------------------------------------------------------
//! @brief     Calculate lengthnof the null terminated string.
//! @note      None
//! @param     [in] *c8_Value Pointer to null terminated string.
//! @return    String length as U32 value.
//! @attention None
//------------------------------------------------------------------------------
 
extern U32 String_Length( C8 *c8_Value );
  
extern BOOL Is_Hex_Digit( C8 c8_Value );
 
extern VOID U8_To_Hex_String( C8 *c8_String, U8 u8_Value );
 
extern VOID U16_To_Hex_String( C8 *c8_String, U16 u16_Value );
 
extern VOID U32_To_Hex_String( C8 *c8_String, U32 u32_Value );
 
extern VOID U64_To_Hex_String( C8 *c8_String, U64 u64_Value );
 
extern U32 Get_String_Chunk_Count( C8 *c8_Input_String, C8 c8_Delimiter );
 
extern VOID Get_String_Chunk( C8 *c8_Chunk_String, C8 *c8_Input_String, C8 c8_Delimiter, U32 u32_Chunk_Index );
 
//------------------------------------------------------------------------------
// End of file
//------------------------------------------------------------------------------