Common Public API

Public utility functions available to all modules. More...

Collaboration diagram for Common Public API:

Functions
uint32_t	get_str_len (char const *str)
	Returns the length of a string, excluding the null terminator.
void	int_to_str (int num, char *str)
	Converts an integer to its decimal string representation.
int	str_to_int (const char *str)
	Converts a decimal string to an integer.
void	double_to_str (double num, char *str, int8_t frac_digits)
	Converts a double to a decimal string with a fixed number of fractional digits.
void	hex_byte_to_str (uint8_t byte, char *str)
	Converts a single byte to a two-character uppercase hexadecimal string.
void	str_set (char *target_str, char const *host_str, uint32_t host_str_len, uint32_t pos)
	Overwrites a region of a target string with the contents of a source string.
int32_t	get_pow (int32_t base, int32_t exponent)
	Computes an integer power.
void	arr_cmprs (char *arr, uint8_t len)
	Compresses an array by removing null bytes and shifting remaining elements left.
bool	str_cmp (const char *str1, const char *str2)
	Compares two null-terminated strings for equality.
uint8_t	ascii_hex_to_byte (char high, char low)
	Converts two ASCII hex characters into a single byte value.
int	str_tokenize (char *str, const char *separator, uint16_t max_tokens, char **tokens, uint16_t *num_tokens)
	Splits a string into tokens separated by a given delimiter.
bool	str_to_bool (char const *str)
	Converts a string representation of a boolean to a bool value.
int	str_cpy (char *str_to, const char *str_from, uint32_t len)
	Copies a null-terminated string into a destination buffer.
int	txt_cpy (char *txt_to, const char *txt_from, uint32_t len)
	Copies a fixed-length block of text into a destination buffer.
bool	is_pow (uint32_t num)
	Checks whether a number is a power of two.
uint32_t	extract_bits (const uint8_t *data, uint16_t start_bit, uint8_t num_bits)
	Extracts a range of bits from a big-endian byte array.

Detailed Description

Public utility functions available to all modules.

Function Documentation

get_str_len()

uint32_t get_str_len

(

char const *

str

)

Returns the length of a string, excluding the null terminator.

Parameters

[in]

str

Pointer to a null-terminated string.

Returns

Number of characters before the null terminator.

See also

get_str_len

Definition at line 22 of file common.c.

                                      {
    uint32_t len = 0;
 
    while(*str++) {
        len++;
    }
 
    return len;
}

Here is the caller graph for this function:

int_to_str()

void int_to_str	(	int	num,
		char *	str )

Converts an integer to its decimal string representation.

Handles negative values. The result is written into str, which must be large enough to hold the digits, an optional leading '-', and the null terminator.

Parameters

[in]	num	The integer to convert.
[out]	str	Pointer to the destination buffer.

See also

int_to_str

Definition at line 33 of file common.c.

                                    {
    char *start = str;
    bool is_negative = false;
 
    if (num < 0) {
        is_negative = true;
        num = -num;  
    }
    if (num == 0) {
        *str++ = '0';
    }
 
    while (num > 0) {
        uint8_t digit = num % 10;
        num = num / 10;
 
        *str++ = (char)(digit + '0');
    }
 
    if (is_negative) {
        *str++ = '-';
    }
 
    *str = '\0';
 
    char *end = str - 1;
    while (start < end) {
        char tmp = *start;
        *start = *end;
        *end = tmp;
        start++;
        end--;
    }
}

Here is the caller graph for this function:

str_to_int()

int str_to_int

(

const char *

str

)

Converts a decimal string to an integer.

Handles an optional leading '-' for negative values. Non-digit characters after the sign are not validated.

Parameters

[in]

str

Pointer to a null-terminated decimal string.

Returns

The parsed integer value.

See also

str_to_int

Definition at line 69 of file common.c.

                                {
    bool negative = false;
    uint8_t num_array[12] = { 0 };
    uint8_t digit_counter = 0;
    int32_t num = 0;
 
    if(*str == '-') {
        negative = true;
        str++;
    }
 
    while(*str) {
        num_array[digit_counter] = *str - 48;
 
        digit_counter++;
        str++;
    }
 
    uint32_t multiplier = 1;
    for(int8_t i = digit_counter - 1; i >= 0 ; i--) {
        num += num_array[i] * multiplier;
 
        multiplier *= 10;
    }
 
    if(negative) {
        num *= -1;
    }
 
    return num;
}

Here is the caller graph for this function:

double_to_str()

void double_to_str	(	double	num,
		char *	str,
		int8_t	frac_digits )

Converts a double to a decimal string with a fixed number of fractional digits.

Handles negative values, including values in the range (-1, 0). Leading zeros in the fractional part are preserved.

Parameters

[in]	num	The double value to convert.
[out]	str	Pointer to the destination buffer. Must be large enough for the integer part, '.', fractional digits, and null terminator.
[in]	frac_digits	Number of digits to include after the decimal point.

See also

double_to_str

Definition at line 102 of file common.c.

                                                              {
    int32_t int_part;
    double frac_part;
    uint8_t int_part_len;
    uint8_t frac_part_len;
    uint8_t total_len = 0;
    double addend;
    uint8_t missing_zeroes = 0;
    bool negative_0_to_1 = false;
 
    if(num > -1 && num < 0) {                   
        negative_0_to_1 = true;
    }
 
    int_part = (int32_t)num;
    frac_part = ((num - (double)int_part) * get_pow(10, frac_digits));
 
    addend = 1.0 / (20 * get_pow(10, frac_digits));
    
    if(frac_part < 0) {
        frac_part -= addend;
        frac_part *= -1;
    }
    else {
        frac_part += addend;
    }
 
    for(uint8_t i = 1; i <= frac_digits; i++) {
        int32_t comp_to_frac = (get_pow(10, frac_digits - i));
 
        if(frac_part < comp_to_frac) {
            missing_zeroes++;
        }
        else {
            break;
        }
    }
    total_len += missing_zeroes;
 
    char int_buf[20] = { 0 };
    if(negative_0_to_1) {
        int_buf[0] = '-';
        int_to_str(int_part, int_buf + 1);
    }
    else {
        int_to_str(int_part, int_buf);
    }
    int_part_len = get_str_len(int_buf);
    total_len += int_part_len;
 
    char double_buf[12] = { 0 };
    int_to_str((int32_t)frac_part, double_buf);
    frac_part_len = get_str_len(double_buf);
    total_len += frac_part_len;
 
    int_buf[int_part_len] = '.';
    total_len++;
 
    for(uint8_t i = 0; i < missing_zeroes; i++) {
        int_buf[int_part_len + 1 + i] = '0';
    }
 
    str_set(int_buf, double_buf, frac_part_len, total_len - frac_part_len);
 
    int_buf[total_len] = '\0';
    total_len++;
 
    for(uint8_t i = 0; i < total_len; i++) {
        str[i] = int_buf[i];
    } 
}

Here is the call graph for this function:

Here is the caller graph for this function:

hex_byte_to_str()

void hex_byte_to_str	(	uint8_t	byte,
		char *	str )

Converts a single byte to a two-character uppercase hexadecimal string.

Does not append a null terminator. The caller must ensure str points to a buffer of at least 2 bytes.

Parameters

[in]	byte	The byte to convert.
[out]	str	Pointer to a buffer that will receive the two hex characters.

See also

hex_byte_to_str

Definition at line 175 of file common.c.

                                              {
    uint8_t first_part = byte / 16;
    uint8_t second_part = byte % 16;
 
    if(first_part < 10) {
        str[0] = (byte / 16) + 48;
    }
    else {
        str[0] = (byte / 16) + 55;
    }
 
    if(second_part < 10) {
        str[1] = (byte % 16) + 48;
    }
    else {
        str[1] = (byte % 16) + 55;
    }
}

str_set()

void str_set	(	char *	target_str,
		char const *	host_str,
		uint32_t	host_str_len,
		uint32_t	pos )

Overwrites a region of a target string with the contents of a source string.

Copies host_str_len characters from host_str into target_str starting at byte offset pos. No null terminator is written.

Parameters

[in,out]	target_str	Pointer to the string to modify.
[in]	host_str	Pointer to the source string.
[in]	host_str_len	Number of characters to copy from host_str.
[in]	pos	Byte offset in target_str at which to begin writing.

See also

str_set

Definition at line 195 of file common.c.

                                                                                          {
    uint32_t pos_counter = 0;
    bool pos_reached = false;
    uint32_t bytes_replaced = 0;
 
    while(bytes_replaced != host_str_len) {
        if(pos_counter == pos) {
            pos_reached = true;
        }
 
        if(pos_reached) {
            *target_str = host_str[bytes_replaced];
            bytes_replaced++;
 
            if(bytes_replaced == host_str_len) {
                break;
            }
        }
 
        target_str++;
        pos_counter++;
    }
}

Here is the caller graph for this function:

get_pow()

int32_t get_pow	(	int32_t	base,
		int32_t	exponent )

Computes an integer power.

Parameters

[in]	base	The base value.
[in]	exponent	The exponent value. Must be non-negative.

Returns

base raised to the power of exponent.

See also

get_pow

Definition at line 220 of file common.c.

                                                {
    int32_t result = 1;
 
    for(int32_t i = 0; i < exponent; i++) {
        result *= base;
    }
 
    return result;
}

Here is the caller graph for this function:

arr_cmprs()

void arr_cmprs	(	char *	arr,
		uint8_t	len )

Compresses an array by removing null bytes and shifting remaining elements left.

All non-null characters are packed to the front of the array. Trailing positions are filled with null bytes.

Parameters

[in,out]	arr	Pointer to the character array to compress.
[in]	len	Total length of the array in bytes.

See also

arr_cmprs

Definition at line 231 of file common.c.

                                       {
    uint8_t write = 0;
 
    for(uint8_t read = 0; read < len; read++) {
        if(arr[read] != '\0') {
            arr[write] = arr[read];
            write++;
        }
    }
 
    while(write < len) {
        arr[write] = '\0';
        write++;
    }
}

Here is the caller graph for this function:

str_cmp()

bool str_cmp	(	const char *	str1,
		const char *	str2 )

Compares two null-terminated strings for equality.

Parameters

[in]	str1	Pointer to the first string.
[in]	str2	Pointer to the second string.

Returns

true if both strings are identical, false otherwise.

See also

str_cmp

Definition at line 248 of file common.c.

                                                 {
    while(*str1 != '\0' && *str2 != '\0') {
        if(*str1 != *str2) {
            return false;
        }
        str1++;
        str2++;
    }
 
    if(*str1 == '\0' && *str2 == '\0') {
        return true;
    }
 
    return false;
}

Here is the caller graph for this function:

ascii_hex_to_byte()

uint8_t ascii_hex_to_byte	(	char	high,
		char	low )

Converts two ASCII hex characters into a single byte value.

Accepts uppercase hex digits (0–9, A–F). Lowercase is not handled.

Parameters

[in]	high	The most significant nibble as an ASCII character (e.g. 'A').
[in]	low	The least significant nibble as an ASCII character (e.g. 'F').

Returns

The combined byte value (e.g. 'A', 'F' → 0xAF).

See also

ascii_hex_to_byte

Definition at line 265 of file common.c.

                                               {
    uint8_t value = 0;
    uint8_t nibble;
 
    if (high >= '0' && high <= '9')
        nibble = (uint8_t)(high - '0');
    else
        nibble = (uint8_t)(high - 'A' + 10);
 
    value = (uint8_t)(nibble << 4);
 
    if (low >= '0' && low <= '9')
        nibble = (uint8_t)(low - '0');
    else
        nibble = (uint8_t)(low - 'A' + 10);
 
    value |= nibble;
 
    return value;
}

Here is the caller graph for this function:

str_tokenize()

int str_tokenize	(	char *	str,
		const char *	separator,
		uint16_t	max_tokens,
		char **	tokens,
		uint16_t *	num_tokens )

Splits a string into tokens separated by a given delimiter.

Modifies str in place by replacing delimiter characters with null bytes. Leading spaces before each token are skipped. Pointers to the start of each token are stored in tokens.

Parameters

[in,out]	str	Pointer to the null-terminated input string. Modified in place.
[in]	separator	Null-terminated string containing the delimiter character(s).
[in]	max_tokens	Maximum number of tokens to extract.
[out]	tokens	Array of pointers that will be set to the start of each token.
[out]	num_tokens	Pointer to a variable that will receive the number of tokens found.

Returns

0 on success, -1 if the token limit is exceeded or the input is empty.

See also

str_tokenize

Definition at line 287 of file common.c.

                                                                                                             {
    while(true) {
        while(*str == ' ') {
            str++;
        }
 
        if(*str == '\0') {
            return -1;
        }
 
        if(*num_tokens <= max_tokens) {         
            tokens[*num_tokens] = str;
            *num_tokens = *num_tokens + 1;
        }
        else {
            return -1;
        }
 
        while(*str && *str != *separator) {
            str++;
        }
 
        if(*str == '\0') {
            break;
        }
 
        *str++ = '\0';
    }
 
    return 0;
}

Here is the caller graph for this function:

str_to_bool()

bool str_to_bool

(

char const *

str

)

Converts a string representation of a boolean to a bool value.

Recognizes the strings "true" and "false" (case-sensitive). Any other input returns false.

Parameters

[in]

str

Pointer to a null-terminated string.

Returns

true if str equals "true", false otherwise.

See also

str_to_bool

Definition at line 320 of file common.c.

                                  {
    if(str_cmp(str, "true") == true) {
        return true;
    }
    else if(str_cmp(str, "false") == true) {
        return false;
    }
 
    // Error
    return false;
}

Here is the call graph for this function:

str_cpy()

int str_cpy	(	char *	str_to,
		const char *	str_from,
		uint32_t	len )

Copies a null-terminated string into a destination buffer.

Copies at most len - 1 characters from str_from into str_to and always null-terminates the result. Stops early if the source string ends before len - 1 characters are copied.

Parameters

[out]	str_to	Pointer to the destination buffer.
[in]	str_from	Pointer to the null-terminated source string.
[in]	len	Total size of the destination buffer in bytes, including space for the null terminator.

Returns

0 on success, -1 if any argument is NULL or len is 0.

See also

str_cpy

Definition at line 333 of file common.c.

{
    if (len == 0 || str_to == (void*)0 || str_from == (void*)0) {
        return -1;
    }
 
    while (*str_from && len > 1) {
        *str_to++ = *str_from++;
        len--;
    }
 
    *str_to = '\0';   // always null-terminate
 
    return 0;
}

Here is the caller graph for this function:

txt_cpy()

int txt_cpy	(	char *	txt_to,
		const char *	txt_from,
		uint32_t	len )

Copies a fixed-length block of text into a destination buffer.

Unlike str_cpy, this function copies exactly len bytes and does not append a null terminator. It stops early if the source ends.

Parameters

[out]	txt_to	Pointer to the destination buffer.
[in]	txt_from	Pointer to the source text.
[in]	len	Number of bytes to copy.

Returns

0 on success, -1 if any argument is NULL or len is 0.

See also

txt_cpy

Definition at line 350 of file common.c.

                                                              {
    if (len == 0 || txt_to == (void*)0 || txt_from == (void*)0) {
        return -1;
    }
 
    while (*txt_from && len != 0) {
        *txt_to++ = *txt_from++;
        len--;
    }
 
    return 0;   
}

Here is the caller graph for this function:

is_pow()

bool is_pow

(

uint32_t

num

)

Checks whether a number is a power of two.

Parameters

[in]

num

The value to test.

Returns

true if num is a non-zero power of two, false otherwise.

See also

is_pow

Definition at line 364 of file common.c.

                          {
    return num && !(num & (num - 1));
}

Here is the caller graph for this function:

extract_bits()

uint32_t extract_bits	(	const uint8_t *	data,
		uint16_t	start_bit,
		uint8_t	num_bits )

Extracts a range of bits from a big-endian byte array.

Bit numbering follows big-endian convention: bit 0 of the array is the most significant bit of the first byte. Extracted bits are assembled into the result with the first extracted bit as the MSB.

Parameters

[in]	data	Pointer to the byte array to extract from.
[in]	start_bit	Index of the first bit to extract (0 = MSB of data[0]).
[in]	num_bits	Number of consecutive bits to extract.

Returns

The extracted bits packed into a uint32_t, MSB-first.

See also

extract_bits

Definition at line 369 of file common.c.

                                                                                 {
    uint32_t result = 0;
    uint16_t byte_index = start_bit / 8;
    uint8_t bit_offset = start_bit % 8;
    
    for (int i = 0; i < num_bits; i++) {
        // SD card registers are big-endian, bit 127 is MSB of first byte
        if (data[byte_index] & (1 << (7 - bit_offset))) {
            result |= (1 << (num_bits - 1 - i));
        }
        
        bit_offset++;
        if (bit_offset >= 8) {
            bit_offset = 0;
            byte_index++;
        }
    }
    
    return result;
}

Here is the caller graph for this function: