ketCube_common.h

Go to the documentation of this file.

 
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __KETCUBE_COMMON_H
#define __KETCUBE_COMMON_H
 
/* Includes ------------------------------------------------------------------*/
#ifndef DESKTOP_BUILD
#include "stm32l0xx_hal.h"
#include "stm32l0xx_hal_gpio.h"
#else
#include "stdint.h"
#endif
#include "stdlib.h"
#include "stdbool.h"
 
#define TRUE    1               
#define FALSE   0               
 
/*typedef enum {
  TRUE       = 1,
  FALSE      = 0
} bool;*/
 
typedef uint8_t byte;
 
extern void KETCube_ErrorHandler(void);
 
#define KETCUBE_COMMON_BUFFER_LEN    256
extern char ketCube_common_buffer[];    
char * ketCube_common_bytes2Str(uint8_t * byteArr, uint8_t len);
 
static inline void ketCube_common_Byte2hex(uint8_t byte, char *str)
{
    if ((byte & 0x0F) < 10) {
        str[1] = (byte & 0x0F) + '0';
    } else {
        str[1] = (byte & 0x0F) - 10 + 'A';
    }
 
    if (((byte & 0xF0) >> 4) < 10) {
        str[0] = ((byte & 0xF0) >> 4) + '0';
    } else {
        str[0] = ((byte & 0xF0) >> 4) - 10 + 'A';
    }
}
 
static inline void ketCube_common_Int2dec(int32_t number, char *str,
                                          int len)
{
    int pos = 0, rem;
    char tmp;
 
    if (number < 0) {
        (*str++) = '-';         // a dirty trick to avoid reversing the minus sign
        len--;
        number *= -1;
    }
 
    while (number != 0 && pos < len) {
        rem = number % 10;
        number /= 10;
 
        str[pos++] = '0' + rem;
    }
 
    for (int rem = 0; rem < pos / 2; rem++) {
        tmp = str[rem];
        str[rem] = str[pos - 1 - rem];
        str[pos - 1 - rem] = tmp;
    }
 
    str[pos] = '\0';
}
 
static inline bool ketCube_common_IsHexString(const char *str, uint8_t len)
{
    uint8_t i = 0;
 
    for (i = 0; i < len; i++) {
        if ((str[i] >= 'A') && (str[i] <= 'F')) {
            continue;
        } else if ((str[i] >= 'a') && (str[i] <= 'f')) {
            continue;
        } else if ((str[i] >= '0') && (str[i] <= '9')) {
            continue;
        } else {
            return FALSE;
        }
    }
 
    return TRUE;
}
 
static inline bool ketCube_common_IsDecString(const char *str, uint8_t len)
{
    uint8_t i = 0;
 
    for (i = 0; i < len && str[i] != '\0'; i++) {
        if ((str[i] < '0') || (str[i] > '9'))
            return FALSE;
    }
 
    return TRUE;
}
 
 
static inline uint8_t ketCube_common_Hex2Val(const char c) {
    
    if ((c >= '0') && (c <= '9')) {
        return (c - '0') & 0x0F;
    } else if ((c >= 'A') && (c <= 'F')) {
        return (c - 'A' + 10) & 0x0F;
    } else if ((c >= 'a') && (c <= 'f')) {
        return (c - 'a' + 10) & 0x0F;
    } else {
        return 0xFF;
    }
                                               
}
 
static inline void ketCube_common_Hex2Bytes(uint8_t * bytes, const char *str,
                                            uint8_t len)
{
    uint8_t i = 0, j = 0;
    uint8_t conv0, conv1;
 
    if (len == 0) {
        return;
    }
 
    for (i = 0; i < (len - 1); i += 2, j++) {
        conv0 = ketCube_common_Hex2Val(str[i]);
        conv1 = ketCube_common_Hex2Val(str[i + 1]);
        
        if ((conv0 < 0x10) && ((conv1 < 0x10))) {
            bytes[j] = (conv0 << 4) | conv1;
        } else {
            /* return earlier in case of error */
            return;
        }
    }
 
    if (i == (len - 1)) {
        conv0 = ketCube_common_Hex2Val(str[i]);
        
        if (conv0 < 0x10) {
            bytes[j] = conv0 << 4;
        } else {
            /* return earlier in case of error */
            return;
        }
    }
}
 
static inline void ketCube_common_Dec2int(int32_t * output, const char *str,
                                          uint8_t len)
{
    uint8_t sign = FALSE;
    int pos;
 
    if (len == 0) {
        return;
    }
 
    *output = 0;
 
    if (str[0] == '-') {
        sign = TRUE;
        str++;
        len--;
    }
 
    for (pos = 0; pos < len && str[pos] != '\0'; pos++) {
        *output *= 10;
        *output += str[pos] - '0';
    }
 
    if (sign == TRUE)
        *output *= -1;
}
 
 
static inline uint8_t ketCube_common_Min(uint8_t a, uint8_t b)
{
    if (a < b)
        return a;
    else
        return b;
}
 
static inline uint8_t ketCube_common_Max(uint8_t a, uint8_t b)
{
    if (a > b)
        return a;
    else
        return b;
}
 
 
static inline uint16_t ketCube_common_Med(uint16_t * values, uint16_t size)
{
    uint16_t i, j, tmp;
 
    // bubble-sort -- it's efficient for small arrays
    for (i = 0; i < size - 1; i++) {
        for (j = 0; j < size - 1 - i; j++) {
            if (values[j] < values[j + 1]) {
                tmp = values[j];
                values[j] = values[j + 1];
                values[j + 1] = tmp;
            }
        }
    }
 
    return (uint16_t) values[size / 2];
}
 
static inline uint32_t ketCube_common_Med32(uint32_t * values, uint32_t size)
{
    uint32_t i, j, tmp;
 
    // bubble-sort -- it's efficient for small arrays
    for (i = 0; i < size - 1; i++) {
        for (j = 0; j < size - 1 - i; j++) {
            if (values[j] < values[j + 1]) {
                tmp = values[j];
                values[j] = values[j + 1];
                values[j + 1] = tmp;
            }
        }
    }
 
    return (uint32_t) values[size / 2];
}
 
static inline uint32_t ketCube_common_Max32(uint32_t * values, uint32_t size)
{
    uint32_t i, max;
    
    max = values[0];
 
    for (i = 0; i < size; i++) {
        if (values[i] > max) {
            max = values[i];
        }
    }
 
    return max;
}
 
static inline uint32_t ketCube_common_Min32(uint32_t * values, uint32_t size)
{
    uint32_t i, min;
    
    min = values[0];
 
    for (i = 0; i < size; i++) {
        if (values[i] < min) {
            min = values[i];
        }
    }
 
    return min;
}
 
static inline uint16_t ketCube_common_Avg(uint16_t * values, uint16_t size)
{
    uint16_t i;
    uint32_t result = 0;
 
    // average
    for (i = 0; i < size; i++) {
        result += values[i];
    }
 
    result = result / size;
 
    return (uint16_t) result;
}
 
 
static inline uint16_t ketCube_common_swapW(uint16_t n)
{
    return ((n >> 8) | (n << 8));
}
 
static inline void ketCube_common_BasicErrorHandler()
{
    while (TRUE) {
        // do nothing
    }
}
 
 
// Include project-specific common here
#ifndef DESKTOP_BUILD
#include "ketCube_projectCommon.h"
#endif
 
 
#endif                          /* __KETCUBE_COMMON_H */