Michal
/
esphome_elektromer_han
mirror of https://github.com/Tomer27cz/xt211.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
esphome_elektromer_han/components/xt211/bytebuffer.c

1310 lines
30 KiB
C
Raw Blame History

//
// --------------------------------------------------------------------------
// 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
//---------------------------------------------------------------------------
#include "gxmem.h"
#ifndef DLMS_IGNORE_STRING_CONVERTER
#include <stdio.h> //printf needs this or error is generated.
#endif //DLMS_IGNORE_STRING_CONVERTER
#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)
#include <assert.h>
#if _MSC_VER > 1400
#include <crtdbg.h>
#endif
#endif
#include <string.h>
#include "errorcodes.h"
#include "bytebuffer.h"
#include "helpers.h"
char bb_isAttached(gxByteBuffer* arr)
{
if (arr == NULL)
{
return 0;
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
//If byte buffer is attached.
return (arr->capacity & 0x80000000) == 0x80000000;
#else
return (arr->capacity & 0x8000) == 0x8000;
#endif
}
#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
{
if (arr == NULL)
{
return 0;
}
return arr->size - arr->position;
}
#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
{
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER)&& (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
//If byte buffer is attached.
return arr->capacity & 0x7FFFFFFF;
#else
return arr->capacity & 0x7FFF;
#endif
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
uint32_t bb_size(gxByteBuffer* arr)
#else
uint16_t bb_size(gxByteBuffer* arr)
#endif
{
return arr != NULL ? arr->size : 0;
}
int BYTE_BUFFER_INIT(
gxByteBuffer* arr)
{
arr->capacity = 0;
arr->data = NULL;
arr->position = 0;
arr->size = 0;
return 0;
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
int bb_capacity(
gxByteBuffer* arr,
uint32_t capacity)
#else
int bb_capacity(
gxByteBuffer* arr,
uint16_t capacity)
#endif
{
#ifndef DLMS_IGNORE_MALLOC
//Capacity can't change if it's attached.
if (!bb_isAttached(arr))
{
if (capacity == 0)
{
if (arr->data != NULL)
{
gxfree(arr->data);
arr->data = NULL;
arr->size = 0;
}
}
else
{
if (arr->capacity == 0)
{
arr->data = (unsigned char*)gxmalloc(capacity);
if (arr->data == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
}
else
{
#ifdef gxrealloc
//If compiler supports realloc.
unsigned char* tmp = (unsigned char*)gxrealloc(arr->data, capacity);
//If not enought memory available.
if (tmp == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
arr->data = tmp;
#else
//If compiler doesn't support realloc.
unsigned char* old = arr->data;
arr->data = (unsigned char*)gxmalloc(capacity);
//If not enought memory available.
if (arr->data == NULL)
{
arr->data = old;
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
memcpy(arr->data, old, arr->size);
gxfree(old);
#endif // gxrealloc
}
if (arr->size > capacity)
{
arr->size = capacity;
}
}
arr->capacity = capacity;
}
#endif //DLMS_IGNORE_MALLOC
if (bb_getCapacity(arr) < capacity)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
return DLMS_ERROR_CODE_OK;
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
int bb_zero(
gxByteBuffer* arr,
uint32_t index,
uint32_t count)
#else
int bb_zero(
gxByteBuffer* arr,
uint16_t index,
uint16_t count)
#endif
{
int ret;
if (index + count > arr->capacity)
{
if ((ret = bb_capacity(arr, (index + count))) != 0)
{
return ret;
}
}
if (arr->size < index + count)
{
arr->size = index + count;
}
memset(arr->data + index, 0, count);
return 0;
}
int bb_setUInt8(
gxByteBuffer* arr,
unsigned char item)
{
int ret = bb_setUInt8ByIndex(arr, bb_size(arr), item);
if (ret == 0)
{
++arr->size;
}
return ret;
}
#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
{
int ret;
if ((ret = bb_move(arr, index, index + 1, arr->size)) == 0)
{
if (index == 0 && arr->size == 0)
{
//If buffer is empty and there is no data to move.
++arr->size;
}
ret = bb_setUInt8ByIndex(arr, index, item);
}
return ret;
}
#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
{
#ifndef DLMS_IGNORE_MALLOC
if (!bb_isAttached(arr) && (arr->capacity == 0 || index + dataSize > arr->capacity))
{
unsigned char empty = arr->capacity == 0;
//If data is append fist time.
if (dataSize > VECTOR_CAPACITY || arr->capacity == 0)
{
arr->capacity += dataSize;
}
else
{
arr->capacity += VECTOR_CAPACITY;
}
if (empty)
{
arr->data = (unsigned char*)gxmalloc(arr->capacity);
if (arr->data == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
}
else
{
#ifdef gxrealloc
//If compiler supports realloc.
unsigned char* tmp = (unsigned char*)gxrealloc(arr->data, arr->capacity);
if (tmp == NULL)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
arr->data = tmp;
#else
//If compiler doesn't supports realloc.
unsigned char* old = arr->data;
arr->data = (unsigned char*)gxmalloc(arr->capacity);
//If not enought memory available.
if (arr->data == NULL)
{
arr->data = old;
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
memcpy(arr->data, old, arr->size);
gxfree(old);
#endif //gxrealloc
}
}
#endif //DLMS_IGNORE_MALLOC
if (bb_getCapacity(arr) < index + dataSize)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
return 0;
}
#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
{
if (arr == NULL)
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
int ret = bb_allocate(arr, index, 1);
if (ret == 0)
{
arr->data[index] = item;
}
return ret;
}
int bb_setUInt16(
gxByteBuffer* arr,
uint16_t item)
{
int ret = bb_setUInt16ByIndex(arr, arr->size, item);
if (ret == 0)
{
arr->size += 2;
}
return ret;
}
#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 ret = 0;
if (index + 2 > arr->size)
{
bb_allocate(arr, arr->size, 2);
}
if (ret == 0)
{
arr->data[index] = (item >> 8) & 0xFF;
arr->data[index + 1] = item & 0xFF;
}
return ret;
}
int bb_setUInt32(
gxByteBuffer* arr,
uint32_t item)
{
int ret = bb_setUInt32ByIndex(arr, arr->size, item);
if (ret == 0)
{
arr->size += 4;
}
return ret;
}
#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_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
{
int ret = bb_allocate(arr, index, 4);
if (ret == 0)
{
PUT32(arr->data + index, item);
}
return ret;
}
int bb_setUInt64(
gxByteBuffer* arr,
uint64_t item)
{
int ret = bb_allocate(arr, arr->size, 8);
if (ret == 0)
{
((unsigned char*)arr->data)[arr->size + 7] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size + 6] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size + 5] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size + 4] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size + 3] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size + 2] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size + 1] = item & 0xFF;
item >>= 8;
((unsigned char*)arr->data)[arr->size] = item & 0xFF;
arr->size += 8;
}
return ret;
}
#ifndef DLMS_IGNORE_FLOAT32
int bb_setFloat(
gxByteBuffer* arr,
float value)
{
typedef union
{
float value;
char b[sizeof(float)];
} HELPER;
HELPER tmp;
tmp.value = value;
int ret = bb_allocate(arr, arr->size, 4);
if (ret == 0)
{
arr->data[arr->size] = tmp.b[3];
arr->data[arr->size + 1] = tmp.b[2];
arr->data[arr->size + 2] = tmp.b[1];
arr->data[arr->size + 3] = tmp.b[0];
arr->size += 4;
}
return ret;
}
#endif //DLMS_IGNORE_FLOAT32
#ifndef DLMS_IGNORE_FLOAT64
int bb_setDouble(
gxByteBuffer* arr,
double value)
{
typedef union
{
double value;
char b[sizeof(double)];
} HELPER;
HELPER tmp;
tmp.value = value;
int ret = bb_allocate(arr, arr->size, 8);
if (ret == 0)
{
arr->data[arr->size] = tmp.b[7];
arr->data[arr->size + 1] = tmp.b[6];
arr->data[arr->size + 2] = tmp.b[5];
arr->data[arr->size + 3] = tmp.b[4];
arr->data[arr->size + 4] = tmp.b[3];
arr->data[arr->size + 5] = tmp.b[2];
arr->data[arr->size + 6] = tmp.b[1];
arr->data[arr->size + 7] = tmp.b[0];
arr->size += 8;
}
return ret;
}
#endif //DLMS_IGNORE_FLOAT64
int bb_setInt8(
gxByteBuffer* arr,
char item)
{
return bb_setUInt8(arr, (unsigned char)item);
}
int bb_setInt16(
gxByteBuffer* arr,
short item)
{
return bb_setUInt16(arr, (uint16_t)item);
}
int bb_setInt32(
gxByteBuffer* arr,
int32_t item)
{
return bb_setUInt32(arr, (uint32_t)item);
}
int bb_setInt64(
gxByteBuffer* arr,
int64_t item)
{
return bb_setUInt64(arr, (uint64_t)item);
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
int bb_set(
gxByteBuffer* arr,
const unsigned char* pSource,
uint32_t count)
#else
int bb_set(
gxByteBuffer* arr,
const unsigned char* pSource,
uint16_t count)
#endif
{
if (count != 0)
{
int ret = bb_allocate(arr, arr->size, count);
if (ret == 0)
{
if (arr->size + count > arr->capacity)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
memcpy(arr->data + arr->size, pSource, count);
arr->size += count;
}
return ret;
}
else
{
return 0;
}
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
int bb_set2(
gxByteBuffer* arr,
gxByteBuffer* data,
uint32_t index,
uint32_t count)
#else
int bb_set2(
gxByteBuffer* arr,
gxByteBuffer* data,
uint16_t index,
uint16_t count)
#endif
{
if (data != NULL && count != 0)
{
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
if (count == (uint32_t)-1)
#else
if (count == (uint16_t)-1)
#endif
{
count = data->size - index;
}
int ret = bb_set(arr, data->data + index, count);
if (ret == 0)
{
data->position += count;
}
return ret;
}
return 0;
}
int bb_addString(
gxByteBuffer* arr,
const char* value)
{
if (value != NULL)
{
int len = (int)strlen(value);
if (len > 0)
{
int ret = bb_set(arr, (const unsigned char*)value, (uint16_t)(len + 1));
if (ret == 0)
{
//Add end of string, but that is not added to the length.
arr->data[arr->size - 1] = '\0';
--arr->size;
}
return ret;
}
}
return 0;
}
#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)
#else
int bb_attach(
gxByteBuffer* arr,
unsigned char* value,
uint16_t count,
uint16_t capacity)
#endif
{
//If capacity is 1 value is cast t
if (value == NULL || capacity < count)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
arr->data = value;
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
if (capacity >= 0x80000000)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
arr->capacity = (0x80000000 | capacity);
#else
if (capacity >= 0x8000)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
arr->capacity = (uint16_t)(0x8000 | capacity);
#endif
arr->size = count;
arr->position = 0;
return 0;
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
int bb_attachString2(
gxByteBuffer* arr,
char* value,
uint32_t count,
uint32_t capacity)
#else
int bb_attachString2(
gxByteBuffer* arr,
char* value,
uint16_t count,
uint16_t capacity)
#endif
{
return bb_attach(arr, (unsigned char*)value, count, capacity);
}
#ifndef DLMS_IGNORE_MALLOC
int bb_attachString(
gxByteBuffer* arr,
char* value)
{
int len = (int)strlen(value);
int ret = bb_set(arr, (const unsigned char*)value, (uint16_t)len);
gxfree(value);
return ret;
}
#endif //DLMS_IGNORE_MALLOC
int bb_clear(
gxByteBuffer* arr)
{
#ifndef DLMS_IGNORE_MALLOC
//If byte buffer is attached.
if (!bb_isAttached(arr))
{
if (arr->data != NULL)
{
gxfree(arr->data);
arr->data = NULL;
}
arr->capacity = 0;
}
#endif //DLMS_IGNORE_MALLOC
arr->size = 0;
arr->position = 0;
return 0;
}
int bb_empty(
gxByteBuffer* arr)
{
arr->size = 0;
arr->position = 0;
return 0;
}
int bb_getUInt8(
gxByteBuffer* arr,
unsigned char* value)
{
if (arr->position >= arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = ((unsigned char*)arr->data)[arr->position];
++arr->position;
return 0;
}
int bb_getInt8(
gxByteBuffer* arr,
signed char* value)
{
if (arr->position >= arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = (signed char)((unsigned char*)arr->data)[arr->position];
++arr->position;
return 0;
}
int bb_getUInt8ByIndex(
gxByteBuffer* arr,
uint32_t index,
unsigned char* value)
{
if (index >= arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = ((unsigned char*)arr->data)[index];
return 0;
}
int bb_getUInt16(
gxByteBuffer* arr,
uint16_t* value)
{
if (arr->position + 2 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = (uint16_t)(((unsigned char*)arr->data)[arr->position] << 8 |
((unsigned char*)arr->data)[arr->position + 1]);
arr->position += 2;
return 0;
}
int bb_getUInt32(
gxByteBuffer* arr,
uint32_t* value)
{
if (arr->position + 4 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = GETU32(arr->data + arr->position);
arr->position += 4;
return 0;
}
int bb_getInt16(
gxByteBuffer* arr,
short* value)
{
if (arr->position + 2 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = (short)(((unsigned char*)arr->data)[arr->position] << 8 |
((unsigned char*)arr->data)[arr->position + 1]);
arr->position += 2;
return 0;
}
int bb_getUInt24(
gxByteBuffer* arr,
uint32_t* value)
{
int ret = bb_getUInt24ByIndex(arr, arr->position, value);
arr->position += 3;
return ret;
}
int bb_getInt32(
gxByteBuffer* arr,
int32_t* value)
{
int ret = bb_getUInt32ByIndex(arr, arr->position, (uint32_t*)value);
arr->position += 4;
return ret;
}
int bb_getUInt24ByIndex(
gxByteBuffer* arr,
uint32_t index,
uint32_t* value)
{
if (index + 3 > bb_size(arr))
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = ((uint32_t)(arr->data)[index] << 16) |
((uint32_t)(arr->data)[index + 1] << 8) |
((uint32_t)(arr->data)[index + 2]);
return 0;
}
int bb_getUInt32ByIndex(
gxByteBuffer* arr,
uint32_t index,
uint32_t* value)
{
if (index + 4 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = GETU32(arr->data + index);
return 0;
}
int bb_getInt64(
gxByteBuffer* arr,
int64_t* value)
{
int ret = bb_getUInt64ByIndex(arr, arr->position, (uint64_t*)value);
if (ret == 0)
{
arr->position += 8;
}
return ret;
}
int bb_getUInt64(
gxByteBuffer* arr,
uint64_t* value)
{
int ret = bb_getUInt64ByIndex(arr, arr->position, value);
if (ret == 0)
{
arr->position += 8;
}
return ret;
}
int bb_getUInt64ByIndex(
gxByteBuffer* arr,
uint32_t index,
uint64_t* value)
{
if (index + 8 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = GETU32(arr->data + index);
//Some 32 bit microcontrollers can't handle *value <<= 32;
//For this reason value is sifted on two parts.
*value <<= 16;
*value <<= 16;
*value |= GETU32(arr->data + index + 4);
return 0;
}
int bb_getUInt128ByIndex(
gxByteBuffer* arr,
uint32_t index,
unsigned char* value)
{
int ret = bb_getUInt32ByIndex(arr, index, (uint32_t*)value);
if (ret == 0)
{
ret = bb_getUInt32ByIndex(arr, index + 4, (uint32_t*)value + 1);
if (ret == 0)
{
ret = bb_getUInt32ByIndex(arr, index + 8, (uint32_t*)value + 2);
if (ret == 0)
{
ret = bb_getUInt32ByIndex(arr, index + 12, (uint32_t*)value + 3);
}
}
}
return ret;
}
#ifndef DLMS_IGNORE_FLOAT32
int bb_getFloat(
gxByteBuffer* arr,
float* value)
{
typedef union
{
float value;
char b[sizeof(float)];
} HELPER;
HELPER tmp;
if (arr->position + 4 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
tmp.b[3] = arr->data[arr->position];
tmp.b[2] = arr->data[arr->position + 1];
tmp.b[1] = arr->data[arr->position + 2];
tmp.b[0] = arr->data[arr->position + 3];
*value = tmp.value;
arr->position += 4;
return 0;
}
#endif //DLMS_IGNORE_FLOAT32
#ifndef DLMS_IGNORE_FLOAT64
int bb_getDouble(
gxByteBuffer* arr,
double* value)
{
typedef union
{
double value;
char b[sizeof(double)];
} HELPER;
HELPER tmp;
if (arr->position + 8 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
tmp.b[7] = arr->data[arr->position];
tmp.b[6] = arr->data[arr->position + 1];
tmp.b[5] = arr->data[arr->position + 2];
tmp.b[4] = arr->data[arr->position + 3];
tmp.b[3] = arr->data[arr->position + 4];
tmp.b[2] = arr->data[arr->position + 5];
tmp.b[1] = arr->data[arr->position + 6];
tmp.b[0] = arr->data[arr->position + 7];
*value = tmp.value;
arr->position += 8;
return 0;
}
#endif //DLMS_IGNORE_FLOAT64
int bb_getUInt16ByIndex(
gxByteBuffer* arr,
uint32_t index,
uint16_t* value)
{
if (index + 2 > arr->size)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
*value = (uint16_t)(((unsigned char*)arr->data)[index] << 8 |
((unsigned char*)arr->data)[index + 1]);
return 0;
}
#ifndef DLMS_IGNORE_MALLOC
int bb_addHexString(
gxByteBuffer* arr,
const char* str)
{
uint16_t count;
int ret;
unsigned char* buffer = NULL;
ret = hlp_hexToBytes(str, &buffer, &count);
if (ret != 0)
{
return ret;
}
if (buffer != NULL)
{
bb_set(arr, buffer, count);
gxfree(buffer);
}
return 0;
}
#endif //DLMS_IGNORE_MALLOC
int bb_addHexString2(
gxByteBuffer* arr,
const char* str)
{
if (str == NULL)
{
return 0;
}
int len = (int)strlen(str);
if (len == 0)
{
return 0;
}
int ret = 0;
int lastValue = -1;
for (int pos = 0; pos != len; ++pos)
{
if (*str >= '0' && *str < 'g')
{
if (lastValue == -1)
{
lastValue = hlp_getValue(*str);
}
else if (lastValue != -1)
{
if ((ret = bb_setUInt8(arr, (unsigned char)(lastValue << 4 | hlp_getValue(*str)))) != 0)
{
break;
}
lastValue = -1;
}
}
else if (lastValue != -1)
{
ret = bb_setUInt8(arr, hlp_getValue(*str));
lastValue = -1;
}
++str;
}
return ret;
}
int bb_addLogicalName(
gxByteBuffer* arr,
const unsigned char* str)
{
int ret;
char buffer[25];
if ((ret = hlp_bytesToHex2(str, 6, buffer, sizeof(buffer))) == 0)
{
ret = bb_addString(arr, buffer);
}
return ret;
}
int bb_toHexString2(
gxByteBuffer* arr,
char* buffer,
uint16_t size)
{
return hlp_bytesToHex2(arr->data, (uint16_t)arr->size, buffer, size);
}
#if !(defined(DLMS_IGNORE_STRING_CONVERTER) || defined(DLMS_IGNORE_MALLOC))
char* bb_toString(
gxByteBuffer* arr)
{
char* buff = (char*)gxmalloc(arr->size + 1);
if (buff != NULL)
{
memcpy(buff, arr->data, arr->size);
*(buff + arr->size) = 0;
}
return buff;
}
char* bb_toHexString(
gxByteBuffer* arr)
{
char* buff = hlp_bytesToHex(arr->data, arr->size);
return buff;
}
int bb_addDoubleAsString(
gxByteBuffer* bb,
double value)
{
char buff[20];
//Show as integer value if there is no fractal part.
if (value - (int32_t)value == 0)
{
return bb_addIntAsString(bb, (int)value);
}
else
{
#if _MSC_VER > 1000
sprintf_s(buff, 20, "%lf", value);
#else
sprintf(buff, "%lf", value);
#endif
return bb_addString(bb, buff);
}
}
#endif //!(defined(DLMS_IGNORE_STRING_CONVERTER) || defined(DLMS_IGNORE_MALLOC))
int bb_addIntAsString(gxByteBuffer* bb, int value)
{
return bb_addIntAsString2(bb, value, 0);
}
int bb_addIntAsString2(gxByteBuffer* bb, int value, unsigned char digits)
{
int ret;
char str[20];
hlp_intToString(str, 20, value, 1, digits);
if ((ret = bb_addString(bb, str)) != 0)
{
}
return ret;
}
#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
{
bb_clear(target);
bb_set2(target, bb, index, count);
return 0;
}
#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
{
int ret;
if (target->size == 0)
{
ret = bb_set(target, src, count);
}
else
{
if ((ret = bb_capacity(target, target->size + count)) == 0 &&
(ret = bb_move(target, index, index + count, target->size - index)) == 0)
{
//Do not use memcpy here!
memmove(target->data + index, src + index, count);
}
}
return ret;
}
#if defined(GX_DLMS_BYTE_BUFFER_SIZE_32) || (!defined(GX_DLMS_MICROCONTROLLER) && (defined(_WIN32) || defined(_WIN64) || defined(__linux__)))
int bb_move(
gxByteBuffer* bb,
uint32_t srcPos,
uint32_t destPos,
uint32_t count)
#else
int bb_move(
gxByteBuffer* bb,
uint16_t srcPos,
uint16_t destPos,
uint16_t count)
#endif
{
//If items are removed.
if (srcPos > destPos)
{
if (bb->size < destPos + count)
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
}
else
{
//Append data.
if (bb_getCapacity(bb) < count + destPos)
{
int ret;
if (bb_isAttached(bb))
{
return DLMS_ERROR_CODE_INVALID_PARAMETER;
}
if ((ret = bb_capacity(bb, count + destPos)) != 0)
{
return ret;
}
}
}
if (count != 0)
{
//Do not use memcpy here!
memmove(bb->data + destPos, bb->data + srcPos, count);
bb->size = (destPos + count);
if (bb->position > bb->size)
{
bb->position = bb->size;
}
}
return DLMS_ERROR_CODE_OK;
}
int bb_trim(
gxByteBuffer* bb)
{
int ret;
if (bb->size == bb->position)
{
bb->size = 0;
}
else
{
if ((ret = bb_move(bb, bb->position, 0, bb->size - bb->position)) != 0)
{
return ret;
}
}
bb->position = 0;
return DLMS_ERROR_CODE_OK;
}
#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
{
unsigned char equal;
if (bb_available(bb) != length)
{
return 0;
}
equal = memcmp(bb->data + bb->position, buff, length) == 0;
if (equal)
{
bb->position += length;
}
return equal;
}
#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
{
if (bb == NULL || value == NULL || bb->size - bb->position < count)
{
return DLMS_ERROR_CODE_OUTOFMEMORY;
}
memcpy(value, bb->data + bb->position, count);
bb->position += count;
return 0;
}
uint32_t bb_indexOf(
gxByteBuffer* bb,
char ch)
{
uint32_t pos;
if (bb == NULL)
{
return (uint32_t)-1;
}
for (pos = bb->position; pos < bb->size; ++pos)
{
if (bb->data[pos] == ch)
{
return pos;
}
}
return (uint32_t)-1;
}
#ifndef GX_DLMS_MICROCONTROLLER
#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)
int bb_print(gxByteBuffer* bb)
{
const char hexArray[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
uint32_t pos;
char hexChars[4];
hexChars[2] = ' ';
hexChars[3] = '\0';
for (pos = 0; pos != bb->size; ++pos)
{
hexChars[0] = hexArray[bb->data[pos] >> 4];
hexChars[1] = hexArray[bb->data[pos] & 0x0F];
printf("%s", hexChars);
}
return 0;
}
#endif //defined(_WIN32) || defined(_WIN64) || defined(__linux__)
#endif //GX_DLMS_MICROCONTROLLER
Reference in New Issue View Git Blame Copy Permalink