can_corex_utils.h

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Author: Adrian Pietrzak
 * GitHub: https://github.com/AdrianPietrzak1998
 * Created: May 18, 2026
 */
 
#ifndef CAN_COREX_CAN_COREX_UTILS_H_
#define CAN_COREX_CAN_COREX_UTILS_H_
 
#include "can_corex.h"
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C"
{
#endif


    typedef enum
    {
        CCX_UTILS_OK = 0,           
        CCX_UTILS_NULL_PTR,         
        CCX_UTILS_WRONG_ARG,        
        CCX_UTILS_BUFFER_TOO_SMALL, 
        CCX_UTILS_UNSUPPORTED       
    } CCX_UTILS_Status_t;

#define CCX_SLCAN_CLASSIC_MAX_LINE_LEN 28U

    CCX_UTILS_Status_t CCX_SLCAN_Parse(const char *line, CCX_message_t *msg);

    CCX_UTILS_Status_t CCX_SLCAN_Format(const CCX_message_t *msg, char *out, size_t out_size);

    CCX_UTILS_Status_t CCX_BytesToHex(const uint8_t *bytes, size_t byte_count, char *out, size_t out_size);

    CCX_UTILS_Status_t CCX_HexToBytes(const char *hex, size_t hex_len, uint8_t *out, size_t out_size,
                                      size_t *bytes_written);

    uint8_t CCX_EncodeLinearU8_Clamped(double physical, double factor, double offset);
    uint16_t CCX_EncodeLinearU16_Clamped(double physical, double factor, double offset);
    uint32_t CCX_EncodeLinearU32_Clamped(double physical, double factor, double offset);
    uint64_t CCX_EncodeLinearU64_Clamped(double physical, double factor, double offset);
 
    int8_t CCX_EncodeLinearS8_Clamped(double physical, double factor, double offset);
    int16_t CCX_EncodeLinearS16_Clamped(double physical, double factor, double offset);
    int32_t CCX_EncodeLinearS32_Clamped(double physical, double factor, double offset);
    int64_t CCX_EncodeLinearS64_Clamped(double physical, double factor, double offset);
 
    double CCX_DecodeLinearU8(uint8_t raw, double factor, double offset);
    double CCX_DecodeLinearU16(uint16_t raw, double factor, double offset);
    double CCX_DecodeLinearU32(uint32_t raw, double factor, double offset);
    double CCX_DecodeLinearU64(uint64_t raw, double factor, double offset);
 
    double CCX_DecodeLinearS8(int8_t raw, double factor, double offset);
    double CCX_DecodeLinearS16(int16_t raw, double factor, double offset);
    double CCX_DecodeLinearS32(int32_t raw, double factor, double offset);
    double CCX_DecodeLinearS64(int64_t raw, double factor, double offset);

    uint8_t CCX_EncodeLinearU8F_Clamped(float physical, float factor, float offset);
    uint16_t CCX_EncodeLinearU16F_Clamped(float physical, float factor, float offset);
    uint32_t CCX_EncodeLinearU32F_Clamped(float physical, float factor, float offset);
    uint64_t CCX_EncodeLinearU64F_Clamped(float physical, float factor, float offset);
 
    int8_t CCX_EncodeLinearS8F_Clamped(float physical, float factor, float offset);
    int16_t CCX_EncodeLinearS16F_Clamped(float physical, float factor, float offset);
    int32_t CCX_EncodeLinearS32F_Clamped(float physical, float factor, float offset);
    int64_t CCX_EncodeLinearS64F_Clamped(float physical, float factor, float offset);
 
    float CCX_DecodeLinearU8F(uint8_t raw, float factor, float offset);
    float CCX_DecodeLinearU16F(uint16_t raw, float factor, float offset);
    float CCX_DecodeLinearU32F(uint32_t raw, float factor, float offset);
    float CCX_DecodeLinearU64F(uint64_t raw, float factor, float offset);
 
    float CCX_DecodeLinearS8F(int8_t raw, float factor, float offset);
    float CCX_DecodeLinearS16F(int16_t raw, float factor, float offset);
    float CCX_DecodeLinearS32F(int32_t raw, float factor, float offset);
    float CCX_DecodeLinearS64F(int64_t raw, float factor, float offset);

 
#ifdef __cplusplus
}
#endif
 
#endif /* CAN_COREX_CAN_COREX_UTILS_H_ */