util_string.h File Reference

String (char array) conversion functionality. More...

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

Go to the source code of this file.

Functions
void	charASCII_to_charHex (char *inbuf, char *outbuf)
	Convert an ASCII char array (string) to a hexadecimal char array. More...
void	uint32_to_charDec (uint32_t value, char *outbuf)
	Convert a uint32_t value to a decimal char array (string). More...
void	uint32_to_charHex (uint32_t value, char *outbuf)
	Convert a uint32_t value to a hexadecimal char array (string). More...
bool	stringStartsWith (char *inbuf, char *sequence)
	Check if a given char array (string) starts with a given sequence. More...
uint8_t	stringLength (char *inbuf)
	Returns the length of the given null-terminated byte string. More...

Detailed Description

String (char array) conversion functionality.

Version

1.0

Author

Brecht Van Eeckhoudt

---

License

Copyright (C) 2020 - Brecht Van Eeckhoudt

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods use code obtained from examples from Silicon Labs' GitHub. These sections are licensed under the Silabs License Agreement. See the file "Silabs_License_Agreement.txt" for details. Before using this software for any purpose, you must agree to the terms of that agreement.

Definition in file util_string.h.

Function Documentation

charASCII_to_charHex()

void charASCII_to_charHex	(	char *	inbuf,
		char *	outbuf
	)

Convert an ASCII char array (string) to a hexadecimal char array.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	inbuf	The given ASCII string to convert to a hexadecimal string.
[out]	outbuf	The buffer to put the resulting string in. This needs to have twice the length of the input message + 1! (two HEX characters for one ASCII character + NULL termination)

Definition at line 63 of file util_string.c.

{
    /* Lookup table array */
    char hex_lut[] = "0123456789abcdef";

    /* Calculate length of the given string */
    uint8_t length = stringLength(inbuf);

    /* Convert each character */
    for (uint16_t i = 0; i < length; i++)
    {
        /* Only get necessary nibble by ANDing with a mask and
         * shifting one nibble (4 bits) per position */
        outbuf[(i*2)]   = hex_lut[(inbuf[i] & 0xF0) >> 4 ];
        outbuf[(i*2)+1] = hex_lut[(inbuf[i] & 0x0F)      ];
    }

    outbuf[length*2] = '\0'; /* NULL termination character */
}

stringLength()

uint8_t stringLength

(

char *

inbuf

)

Returns the length of the given null-terminated byte string.

Parameters

[in]

inbuf

The given char array (string).

Definition at line 224 of file util_string.c.

{
    uint8_t length = 0;

    /* Count up until we reach a NULL */
    while (inbuf[length] != '\0') length++;

    return (length);
}

stringStartsWith()

bool stringStartsWith	(	char *	inbuf,
		char *	sequence
	)

Check if a given char array (string) starts with a given sequence.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	inbuf	The given char array (string) to check a sequence in.
[in]	sequence	The sequence to check in the given char array.

Returns

• true - The given sequence is found in the char array.
• false -The given sequence is not found in the char array.

Definition at line 203 of file util_string.c.

{
    /* Go through each character of "sequence" */
    for (uint8_t i = 0; i < stringLength(sequence); i++ )
    {
        /* Return false if the value at the memory location (pointer, '*') of
         * (inbuf+i) isn't equal to the value at the memory location of (sequence+i) */
        if (*(inbuf+i) != *(sequence+i)) return (false);
    }

    return (true);
}

uint32_to_charDec()

void uint32_to_charDec	(	uint32_t	value,
		char *	outbuf
	)

Convert a uint32_t value to a decimal char array (string).

Parameters

[in]	value	The uint32_t value to convert to a string.
[out]	outbuf	The buffer to put the resulting string in. This needs to have a length of 10: char buf[10];!

Definition at line 95 of file util_string.c.

{
    if (value == 0)
    {
        outbuf[0] = '0';
        outbuf[1] = '\0'; /* NULL termination character */
    }
    else
    {
        /* MAX uint32_t value = FFFFFFFFh = 4294967295d (10 decimal chars) */
        char backwardsBuf[10];

        uint32_t calcval = value;
        uint8_t length = 0;
        uint8_t lengthCounter = 0;


        /* Loop until the value is zero (separate characters 0-9) and calculate length */
        while (calcval)
        {
            uint32_t rem = calcval % 10;
            backwardsBuf[length] = '0' + rem; /* Convert to ASCII character */
            length++;

            calcval = calcval - rem;
            calcval = calcval / 10;
        }

        /* Backwards counter */
        lengthCounter = length;

        /* Reverse the characters in the buffer for the final string */
        for (uint8_t i = 0; i < length; i++)
        {
            outbuf[i] = backwardsBuf[lengthCounter-1];
            lengthCounter--;
        }

        /* Add NULL termination character */
        outbuf[length] = '\0';
    }
}

uint32_to_charHex()

void uint32_to_charHex	(	uint32_t	value,
		char *	outbuf
	)

Convert a uint32_t value to a hexadecimal char array (string).

Parameters

[in]	value	The uint32_t value to convert to a string.
[out]	outbuf	The buffer to put the resulting string in. This needs to have a length of 9: char buf[9];!

Definition at line 150 of file util_string.c.

{
    /* Lookup table array */
    char hex_lut[] = "0123456789abcdef";

    /* 4 nibble HEX representation */
    if (value <= 0xFFFF)
    {
        /* Only get necessary nibble by ANDing with a mask and
         * shifting one nibble (4 bits) per position */
        outbuf[0] = hex_lut[(value & 0xF000) >> 12];
        outbuf[1] = hex_lut[(value & 0x0F00) >> 8 ];
        outbuf[2] = hex_lut[(value & 0x00F0) >> 4 ];
        outbuf[3] = hex_lut[(value & 0x000F)      ];
        outbuf[4] = '\0'; /* NULL termination character */
    }

    /* 8 nibble HEX representation */
    else
    {
        /* Only get necessary nibble by ANDing with a mask and
         * shifting one nibble (4 bits) per position */
        outbuf[0] = hex_lut[(value & 0xF0000000) >> 28];
        outbuf[1] = hex_lut[(value & 0x0F000000) >> 24];
        outbuf[2] = hex_lut[(value & 0x00F00000) >> 20];
        outbuf[3] = hex_lut[(value & 0x000F0000) >> 16];
        outbuf[4] = hex_lut[(value & 0x0000F000) >> 12];
        outbuf[5] = hex_lut[(value & 0x00000F00) >> 8 ];
        outbuf[6] = hex_lut[(value & 0x000000F0) >> 4 ];
        outbuf[7] = hex_lut[(value & 0x0000000F)      ];
        outbuf[8] = '\0'; /* NULL termination character */
    }
}