common.c

Go to the documentation of this file.

 
#include <stdbool.h>
 
#include "common.h"


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

void int_to_str(int num, char *str) {
    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--;
    }
}

int str_to_int(const char* str) {
    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;
}

void double_to_str(double num, char *str, int8_t frac_digits) {
    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];
    } 
}

void hex_byte_to_str(uint8_t byte, char *str) {
    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;
    }
}

void str_set(char *target_str, char const *host_str, uint32_t host_str_len, uint32_t pos) {
    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++;
    }
}

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

void arr_cmprs(char *arr, uint8_t len) {
    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++;
    }
}

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

uint8_t ascii_hex_to_byte(char high, char low) {
    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;
}

int str_tokenize(char *str, const char *separator, uint16_t max_tokens, char **tokens, uint16_t *num_tokens) {
    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;
}

bool str_to_bool(char const *str) {
    if(str_cmp(str, "true") == true) {
        return true;
    }
    else if(str_cmp(str, "false") == true) {
        return false;
    }
 
    // Error
    return false;
}

int str_cpy(char *str_to, const char *str_from, uint32_t len)
{
    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;
}

int txt_cpy(char *txt_to, const char *txt_from, uint32_t len) {
    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;   
}

bool is_pow(uint32_t num) {
    return num && !(num & (num - 1));
}

uint32_t extract_bits(const uint8_t *data, uint16_t start_bit, uint8_t num_bits) {
    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;
}