542 lines
14 KiB
C
542 lines
14 KiB
C
//
|
|
// --------------------------------------------------------------------------
|
|
// Gurux Ltd
|
|
//
|
|
//
|
|
//
|
|
// Filename: $HeadURL$
|
|
//
|
|
// Version: $Revision$,
|
|
// $Date$
|
|
// $Author$
|
|
//
|
|
// Copyright (c) Gurux Ltd
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This file is a part of Gurux Device Framework.
|
|
//
|
|
// Gurux Device Framework is Open Source software; you can redistribute it
|
|
// and/or modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; version 2 of the License.
|
|
// Gurux Device Framework is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// This code is licensed under the GNU General Public License v2.
|
|
// Full text may be retrieved at http://www.gnu.org/licenses/gpl-2.0.txt
|
|
//---------------------------------------------------------------------------
|
|
|
|
#ifndef BYTE_BUFFER_H
|
|
#define BYTE_BUFFER_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "gxint.h"
|
|
#include "gxignore.h"
|
|
|
|
//Arduino DOIT ESP32 uses bb_init. bb_Init is used instead.
|
|
#ifndef ESP_PLATFORM
|
|
#define BYTE_BUFFER_INIT bb_init
|
|
#else
|
|
#define BYTE_BUFFER_INIT bb_Init
|
|
#endif //DESP_PLATFORM
|
|
|
|
#define VECTOR_CAPACITY 50
|
|
|
|
typedef struct
|
|
{
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
unsigned char* data;
|
|
uint32_t capacity;
|
|
uint32_t size;
|
|
uint32_t position;
|
|
#else
|
|
unsigned char* data;
|
|
uint16_t capacity;
|
|
uint16_t size;
|
|
uint16_t position;
|
|
#endif
|
|
} gxByteBuffer;
|
|
|
|
/*
|
|
* Is static buffer used.
|
|
*/
|
|
char bb_isAttached(
|
|
gxByteBuffer* arr);
|
|
|
|
/*Get maximum buffer size.*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
uint32_t bb_getCapacity(
|
|
gxByteBuffer* arr);
|
|
#else
|
|
uint16_t bb_getCapacity(
|
|
gxByteBuffer* arr);
|
|
#endif
|
|
|
|
/*Returns amount of the available bytes.*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
uint32_t bb_available(gxByteBuffer* arr);
|
|
#else
|
|
uint16_t bb_available(gxByteBuffer* arr);
|
|
#endif
|
|
/*
|
|
* Initialize gxByteBuffer.
|
|
*/
|
|
int BYTE_BUFFER_INIT(
|
|
gxByteBuffer* bb);
|
|
|
|
/*
|
|
* Allocate new size for the array in bytes.
|
|
*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_capacity(
|
|
gxByteBuffer* bb,
|
|
uint32_t capacity);
|
|
#else
|
|
int bb_capacity(
|
|
gxByteBuffer* bb,
|
|
uint16_t capacity);
|
|
#endif
|
|
|
|
/*
|
|
* Get size.
|
|
*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
uint32_t bb_size(
|
|
gxByteBuffer* bb);
|
|
#else
|
|
uint16_t bb_size(
|
|
gxByteBuffer* bb);
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Fill buffer it with zeros.
|
|
*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_zero(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
uint32_t count);
|
|
#else
|
|
int bb_zero(
|
|
gxByteBuffer* bb,
|
|
uint16_t index,
|
|
uint16_t count);
|
|
#endif
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_insertUInt8(
|
|
gxByteBuffer* arr,
|
|
uint32_t index,
|
|
unsigned char item);
|
|
#else
|
|
int bb_insertUInt8(
|
|
gxByteBuffer* arr,
|
|
uint16_t index,
|
|
unsigned char item);
|
|
#endif
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_allocate(
|
|
gxByteBuffer* arr,
|
|
uint32_t index,
|
|
uint32_t dataSize);
|
|
#else
|
|
int bb_allocate(
|
|
gxByteBuffer* arr,
|
|
uint16_t index,
|
|
uint16_t dataSize);
|
|
#endif
|
|
//Set new data to the gxByteBuffer.
|
|
int bb_setUInt8(
|
|
gxByteBuffer* bb,
|
|
unsigned char item);
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_setUInt8ByIndex(
|
|
gxByteBuffer* arr,
|
|
uint32_t index,
|
|
unsigned char item);
|
|
#else
|
|
int bb_setUInt8ByIndex(
|
|
gxByteBuffer* arr,
|
|
uint16_t index,
|
|
unsigned char item);
|
|
#endif
|
|
|
|
int bb_setUInt16(
|
|
gxByteBuffer* bb,
|
|
uint16_t item);
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_setUInt16ByIndex(
|
|
gxByteBuffer* arr,
|
|
uint32_t index,
|
|
uint16_t item);
|
|
#else
|
|
int bb_setUInt16ByIndex(
|
|
gxByteBuffer* arr,
|
|
uint16_t index,
|
|
uint16_t item);
|
|
#endif
|
|
|
|
int bb_setUInt32(
|
|
gxByteBuffer* bb,
|
|
uint32_t item);
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_setUInt32ByIndex(
|
|
gxByteBuffer* arr,
|
|
uint32_t index,
|
|
uint32_t item);
|
|
#else
|
|
int bb_setUInt32ByIndex(
|
|
gxByteBuffer* arr,
|
|
uint16_t index,
|
|
uint32_t item);
|
|
#endif //!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__))
|
|
|
|
int bb_setUInt64(
|
|
gxByteBuffer* bb,
|
|
uint64_t item);
|
|
|
|
#ifndef DLMS_IGNORE_FLOAT32
|
|
int bb_setFloat(
|
|
gxByteBuffer* arr,
|
|
float value);
|
|
#endif //DLMS_IGNORE_FLOAT32
|
|
|
|
#ifndef DLMS_IGNORE_FLOAT64
|
|
int bb_setDouble(
|
|
gxByteBuffer* arr,
|
|
double value);
|
|
#endif //DLMS_IGNORE_FLOAT64
|
|
|
|
int bb_setInt8(
|
|
gxByteBuffer* bb,
|
|
char item);
|
|
|
|
int bb_setInt16(
|
|
gxByteBuffer* bb,
|
|
int16_t item);
|
|
|
|
int bb_setInt32(
|
|
gxByteBuffer* bb,
|
|
int32_t item);
|
|
|
|
int bb_setInt64(
|
|
gxByteBuffer* bb,
|
|
int64_t item);
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_insert(
|
|
const unsigned char* src,
|
|
uint32_t count,
|
|
gxByteBuffer* target,
|
|
uint32_t index);
|
|
|
|
#else
|
|
int bb_insert(
|
|
const unsigned char* src,
|
|
uint16_t count,
|
|
gxByteBuffer* target,
|
|
uint16_t index);
|
|
#endif
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_set(
|
|
gxByteBuffer* bb,
|
|
const unsigned char* pSource,
|
|
uint32_t count);
|
|
#else
|
|
int bb_set(
|
|
gxByteBuffer* bb,
|
|
const unsigned char* pSource,
|
|
uint16_t count);
|
|
#endif
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_set2(
|
|
gxByteBuffer* bb,
|
|
gxByteBuffer* data,
|
|
uint32_t index,
|
|
uint32_t count);
|
|
#else
|
|
int bb_set2(
|
|
gxByteBuffer* bb,
|
|
gxByteBuffer* data,
|
|
uint16_t index,
|
|
uint16_t count);
|
|
#endif
|
|
|
|
int bb_addString(
|
|
gxByteBuffer* bb,
|
|
const char* value);
|
|
|
|
int bb_attachString(
|
|
gxByteBuffer* bb,
|
|
char* value);
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_attach(
|
|
gxByteBuffer* arr,
|
|
unsigned char* value,
|
|
uint32_t count,
|
|
uint32_t capacity);
|
|
int bb_attachString2(
|
|
gxByteBuffer* arr,
|
|
char* value,
|
|
uint32_t count,
|
|
uint32_t capacity);
|
|
#else
|
|
int bb_attach(
|
|
gxByteBuffer* arr,
|
|
unsigned char* value,
|
|
uint16_t count,
|
|
uint16_t capacity);
|
|
int bb_attachString2(
|
|
gxByteBuffer* arr,
|
|
char* value,
|
|
uint16_t count,
|
|
uint16_t capacity);
|
|
#endif
|
|
//Clean byte buffer and release allocated memory.
|
|
int bb_clear(
|
|
gxByteBuffer* bb);
|
|
|
|
//Set size and position to zero. Allocated memory is not released.
|
|
int bb_empty(
|
|
gxByteBuffer* bb);
|
|
|
|
int bb_getUInt8(
|
|
gxByteBuffer* bb,
|
|
unsigned char* value);
|
|
|
|
int bb_getUInt8ByIndex(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
unsigned char* value);
|
|
|
|
int bb_getUInt16(
|
|
gxByteBuffer* bb,
|
|
uint16_t* value);
|
|
|
|
int bb_getUInt24(
|
|
gxByteBuffer* bb,
|
|
uint32_t* value);
|
|
|
|
int bb_getUInt32(
|
|
gxByteBuffer* bb,
|
|
uint32_t* value);
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_get(
|
|
gxByteBuffer* bb,
|
|
unsigned char* value,
|
|
uint32_t count);
|
|
#else
|
|
int bb_get(
|
|
gxByteBuffer* bb,
|
|
unsigned char* value,
|
|
uint16_t count);
|
|
#endif
|
|
|
|
int bb_getInt8(
|
|
gxByteBuffer* arr,
|
|
signed char* value);
|
|
|
|
int bb_getInt16(
|
|
gxByteBuffer* bb,
|
|
int16_t* value);
|
|
|
|
int bb_getInt32(
|
|
gxByteBuffer* bb,
|
|
int32_t* value);
|
|
|
|
int bb_getInt64(
|
|
gxByteBuffer* bb,
|
|
int64_t* value);
|
|
|
|
int bb_getUInt64(
|
|
gxByteBuffer* bb,
|
|
uint64_t* value);
|
|
|
|
#ifndef DLMS_IGNORE_FLOAT32
|
|
int bb_getFloat(
|
|
gxByteBuffer* bb,
|
|
float* value);
|
|
#endif //DLMS_IGNORE_FLOAT32
|
|
|
|
#ifndef DLMS_IGNORE_FLOAT64
|
|
int bb_getDouble(
|
|
gxByteBuffer* bb,
|
|
double* value);
|
|
#endif //DLMS_IGNORE_FLOAT64
|
|
|
|
int bb_getUInt16ByIndex(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
uint16_t* value);
|
|
|
|
int bb_getUInt24ByIndex(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
uint32_t* value);
|
|
|
|
int bb_getUInt32ByIndex(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
uint32_t* value);
|
|
|
|
int bb_getUInt64ByIndex(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
uint64_t* value);
|
|
|
|
int bb_getUInt128ByIndex(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
unsigned char* value);
|
|
|
|
#ifndef DLMS_IGNORE_MALLOC
|
|
//Add hex string to byte buffer.
|
|
int bb_addHexString(
|
|
gxByteBuffer* arr,
|
|
const char* str);
|
|
#endif //DLMS_IGNORE_MALLOC
|
|
|
|
//Add hex string to byte buffer.
|
|
int bb_addHexString2(
|
|
gxByteBuffer* arr,
|
|
const char* str);
|
|
|
|
//Add hex string to byte buffer.
|
|
int bb_addLogicalName(
|
|
gxByteBuffer* arr,
|
|
const unsigned char* str);
|
|
|
|
//Get byte array as hex string.
|
|
int bb_toHexString2(
|
|
gxByteBuffer* arr,
|
|
char* buffer,
|
|
uint16_t size);
|
|
|
|
#if !(defined(DLMS_IGNORE_STRING_CONVERTER) || defined(DLMS_IGNORE_MALLOC))
|
|
//Get byte array as a string.
|
|
char* bb_toString(
|
|
gxByteBuffer* bb);
|
|
|
|
//Get byte array as hex string.
|
|
char* bb_toHexString(
|
|
gxByteBuffer* bb);
|
|
|
|
//Add double value to byte array as a string.
|
|
int bb_addDoubleAsString(
|
|
gxByteBuffer* ba,
|
|
double value);
|
|
#endif //!(defined(DLMS_IGNORE_STRING_CONVERTER) || defined(DLMS_IGNORE_MALLOC))
|
|
|
|
//Add integer value to byte array as a string.
|
|
int bb_addIntAsString(
|
|
gxByteBuffer* ba,
|
|
int value);
|
|
|
|
//Add integer value to byte array as a string.
|
|
int bb_addIntAsString2(
|
|
gxByteBuffer* ba,
|
|
int value,
|
|
unsigned char digits);
|
|
|
|
/**
|
|
* Returns data as byte array.
|
|
*
|
|
* @param bb Byte buffer as a byte array.
|
|
*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
int bb_subArray(
|
|
gxByteBuffer* bb,
|
|
uint32_t index,
|
|
uint32_t count,
|
|
gxByteBuffer* target);
|
|
#else
|
|
int bb_subArray(
|
|
gxByteBuffer* bb,
|
|
uint16_t index,
|
|
uint16_t count,
|
|
gxByteBuffer* target);
|
|
#endif
|
|
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
//Move data insize byte array.
|
|
int bb_move(
|
|
gxByteBuffer* ba,
|
|
uint32_t srcPos,
|
|
uint32_t destPos,
|
|
uint32_t count);
|
|
#else
|
|
//Move data insize byte array.
|
|
int bb_move(
|
|
gxByteBuffer* ba,
|
|
uint16_t srcPos,
|
|
uint16_t destPos,
|
|
uint16_t count);
|
|
#endif
|
|
|
|
/**
|
|
* Remove handled bytes. This can be used in debugging to remove handled
|
|
* bytes.
|
|
*/
|
|
int bb_trim(
|
|
gxByteBuffer* bb);
|
|
|
|
/**
|
|
* Compares, whether two given arrays are similar starting from current
|
|
* position.
|
|
*
|
|
* @param bb
|
|
* Bytebuffer to compare.
|
|
* @param arr
|
|
* Array to compare.
|
|
* @param length
|
|
* Array length.
|
|
* @return True, if arrays are similar. False, if the arrays differ.
|
|
*/
|
|
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
|
|
unsigned char bb_compare(
|
|
gxByteBuffer* bb,
|
|
unsigned char* buff,
|
|
uint32_t length);
|
|
#else
|
|
unsigned char bb_compare(
|
|
gxByteBuffer* bb,
|
|
unsigned char* buff,
|
|
uint16_t length);
|
|
#endif
|
|
|
|
//Find index of given char.
|
|
uint32_t bb_indexOf(
|
|
gxByteBuffer* bb,
|
|
char ch);
|
|
|
|
#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)
|
|
//Print content of byte buffer to cout.
|
|
int bb_print(gxByteBuffer* bb);
|
|
#endif //defined(_WIN32) || defined(_WIN64) || defined(__linux__)
|
|
|
|
#define BB_ATTACH(X, V, S) bb_attach(&X, V, S, sizeof(V))
|
|
|
|
#define BB_ATTACH_STR(X, V, S) bb_attachString2(&X, V, S, sizeof(V))
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif //BYTE_BUFFER_H
|