Common Public APIs

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

Function Documentation

get_str_len()

uint32_t get_str_len

(

char const *

str

)

Returns the length of a string, excluding 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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: