nils/ebusd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

introduced type templates, added bit base types, added two-byte time, added precision, added test for any/min/max/replacement/signed min/signed max for all base types

Browse Source
This commit is contained in:
john30
2014-11-16 10:49:47 +01:00
parent 72fcd8623d
commit 63cde34e6a
3 changed files with 580 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/ebus/data.cpp
+284 -160
View File
@@ -26,34 +26,72 @@
#include <iomanip>
#include <vector>
#include <cstring>
#include <typeinfo>
#include <math.h>
namespace libebus
{
/** the known data field types. */
static const dataType_t dataTypes[] = {
{"STR", 16, bt_str, ADJ, ' ', 1, 16, 0}, // >= 1 byte character string filled up with space
{"HEX", 16, bt_hexstr, ADJ, 0, 2, 47, 0}, // >= 1 byte hex digit string, usually separated by space, e.g. 0a 1b 2c 3d
{"BDA", 4, bt_dat, BCD, 0, 10, 10, 0}, // date in BCD, 01.01.2000 - 31.12.2099 (0x01,0x01,WW,0x00 - 0x31,0x12,WW,0x99, WW is ignored weekday)
{"BDA", 3, bt_dat, BCD, 0, 10, 10, 0}, // date in BCD, 01.01.2000 - 31.12.2099 (0x01,0x01,0x00 - 0x31,0x12,0x99)
{"HDA", 4, bt_dat, 0, 0, 10, 10, 0}, // date, 01.01.2000 - 31.12.2099 (0x01,0x01,WW,0x00 - 0x31,0x12,WW,0x99, WW is ignored weekday) // TODO remove duplicate of BDA
{"HDA", 3, bt_dat, 0, 0, 10, 10, 0}, // date, 01.01.2000 - 31.12.2099 (0x01,0x01,0x00 - 0x31,0x12,0x99) // TODO remove duplicate of BDA
{"BTI", 3, bt_tim, BCD|REV, 0, 8, 8, 0}, // time in BCD, 00:00:00 - 23:59:59 (0x00,0x00,0x00 - 0x59,0x59,0x23)
{"TTM", 1, bt_tim, 0, 0, 5, 5, 0}, // truncated time (only multiple of 10 minutes), 00:00 - 24:00 (minutes div 10 + hour * 6 as integer)
{"BDY", 1, bt_num, DAY|LST, 0, 0, 6, 1}, // weekday, "Mon" - "Sun"
{"HDY", 1, bt_num, DAY|LST, 0, 1, 7, 1}, // weekday, "Mon" - "Sun"
{"BCD", 1, bt_num, BCD|LST, 0xff, 0, 0x99, 1}, // unsigned decimal in BCD, 0 - 99
{"UCH", 1, bt_num, LST, 0xff, 0, 0xff, 1}, // unsigned integer, 0 - 255
{"SCH", 1, bt_num, SIG, 0x80, 0x80, 0x7f, 1}, // signed integer, -128 - +127
{"D1B", 1, bt_num, SIG, 0x80, 0x81, 0x7f, 1}, // signed integer, -127 - +127
{"D1C", 1, bt_num, 0, 0xff, 0x00, 0xc8, 2}, // unsigned number (fraction 1/2), 0 - 100 (0x00 - 0xc8, replacement 0xff)
{"UIN", 2, bt_num, LST, 0xffff, 0, 0xffff, 1}, // unsigned integer, 0 - 65535
{"SIN", 2, bt_num, SIG, 0x8000, 0x8000, 0x7fff, 1}, // signed integer, -32768 - +32767
{"FLT", 2, bt_num, SIG, 0x8000, 0x8000, 0x7fff, 1000}, // signed number (fraction 1/1000), -32.768 - +32.767
{"D2B", 2, bt_num, SIG, 0x8000, 0x8001, 0x7fff, 256}, // signed number (fraction 1/256), -127.99 - +127.99
{"D2C", 2, bt_num, SIG, 0x8000, 0x8001, 0x7fff, 16}, // signed number (fraction 1/16), -2047.9 - +2047.9
{"ULG", 4, bt_num, LST, 0xffffffff, 0, 0xffffffff, 1}, // unsigned integer, 0 - 4294967295
{"SLG", 4, bt_num, SIG, 0x80000000, 0x80000000, 0xffffffff, 1}, // signed integer, -2147483648 - +2147483647
{"STR",16*8,bt_str, ADJ, ' ', 1, 16, 0, 0}, // >= 1 byte character string filled up with space
{"HEX",16*8,bt_hexstr, ADJ, 0, 2, 47, 0, 0}, // >= 1 byte hex digit string, usually separated by space, e.g. 0a 1b 2c 3d
{"BDA", 32, bt_dat, BCD, 0, 10, 10, 0, 0}, // date in BCD, 01.01.2000 - 31.12.2099 (0x01,0x01,WW,0x00 - 0x31,0x12,WW,0x99, WW is ignored weekday)
{"BDA", 24, bt_dat, BCD, 0, 10, 10, 0, 0}, // date in BCD, 01.01.2000 - 31.12.2099 (0x01,0x01,0x00 - 0x31,0x12,0x99)
{"HDA", 32, bt_dat, 0, 0, 10, 10, 0, 0}, // date, 01.01.2000 - 31.12.2099 (0x01,0x01,WW,0x00 - 0x31,0x12,WW,0x99, WW is ignored weekday) // TODO remove duplicate of BDA
{"HDA", 24, bt_dat, 0, 0, 10, 10, 0, 0}, // date, 01.01.2000 - 31.12.2099 (0x01,0x01,0x00 - 0x31,0x12,0x99) // TODO remove duplicate of BDA
{"BTI", 24, bt_tim, BCD|REV, 0, 8, 8, 0, 0}, // time in BCD, 00:00:00 - 23:59:59 (0x00,0x00,0x00 - 0x59,0x59,0x23)
{"HTM", 16, bt_tim, 0, 0, 5, 5, 0, 0}, // time as hh:mm, 00:00 - 23:59 (0x00,0x00 - 0x17,0x3b)
{"TTM", 8, bt_tim, 0, 0, 5, 5, 0, 0}, // truncated time (only multiple of 10 minutes), 00:00 - 24:00 (minutes div 10 + hour * 6 as integer)
{"BDY", 8, bt_num, DAY|LST, 0x07, 0, 6, 1, 0}, // weekday, "Mon" - "Sun"
{"HDY", 8, bt_num, DAY|LST, 0x00, 1, 7, 1, 0}, // weekday, "Mon" - "Sun"
{"BCD", 8, bt_num, BCD|LST, 0xff, 0, 0x99, 1, 0}, // unsigned decimal in BCD, 0 - 99
{"UCH", 8, bt_num, LST, 0xff, 0, 0xfe, 1, 0}, // unsigned integer, 0 - 254
{"SCH", 8, bt_num, SIG, 0x80, 0x81, 0x7f, 1, 0}, // signed integer, -127 - +127
{"D1B", 8, bt_num, SIG, 0x80, 0x81, 0x7f, 1, 0}, // signed integer, -127 - +127
{"D1C", 8, bt_num, 0, 0xff, 0x00, 0xc8, 2, 1}, // unsigned number (fraction 1/2), 0 - 100 (0x00 - 0xc8, replacement 0xff)
{"UIN", 16, bt_num, LST, 0xffff, 0, 0xfffe, 1, 0}, // unsigned integer, 0 - 65534
{"SIN", 16, bt_num, SIG, 0x8000, 0x8001, 0x7fff, 1, 0}, // signed integer, -32767 - +32767
{"FLT", 16, bt_num, SIG, 0x8000, 0x8001, 0x7fff, 1000, 3}, // signed number (fraction 1/1000), -32.767 - +32.767
{"D2B", 16, bt_num, SIG, 0x8000, 0x8001, 0x7fff, 256, 3}, // signed number (fraction 1/256), -127.99 - +127.99
{"D2C", 16, bt_num, SIG, 0x8000, 0x8001, 0x7fff, 16, 2}, // signed number (fraction 1/16), -2047.9 - +2047.9
{"ULG", 32, bt_num, LST, 0xffffffff, 0, 0xfffffffe, 1, 0}, // unsigned integer, 0 - 4294967294
{"SLG", 32, bt_num, SIG, 0x80000000, 0x80000001, 0xffffffff, 1, 0}, // signed integer, -2147483647 - +2147483647
{"BI0", 1, bt_num, LST, 0, 0, 0x1, 1, 0}, // single bit 0
{"BI1", 1, bt_num, LST, 0, 0, 0x1, 1, 1}, // single bit 1
{"BI2", 1, bt_num, LST, 0, 0, 0x1, 1, 2}, // single bit 2
{"BI3", 1, bt_num, LST, 0, 0, 0x1, 1, 3}, // single bit 3
{"BI4", 1, bt_num, LST, 0, 0, 0x1, 1, 4}, // single bit 4
{"BI5", 1, bt_num, LST, 0, 0, 0x1, 1, 5}, // single bit 5
{"BI6", 1, bt_num, LST, 0, 0, 0x1, 1, 6}, // single bit 6
{"BI7", 1, bt_num, LST, 0, 0, 0x1, 1, 7}, // single bit 7
{"B01", 2, bt_num, LST, 0, 0, 0x3, 1, 0}, // two bits 0-1
{"B12", 2, bt_num, LST, 0, 0, 0x3, 1, 1}, // two bits 1-2
{"B23", 2, bt_num, LST, 0, 0, 0x3, 1, 2}, // two bits 2-3
{"B34", 2, bt_num, LST, 0, 0, 0x3, 1, 3}, // two bits 3-4
{"B45", 2, bt_num, LST, 0, 0, 0x3, 1, 4}, // two bits 4-5
{"B56", 2, bt_num, LST, 0, 0, 0x3, 1, 5}, // two bits 5-6
{"B67", 2, bt_num, LST, 0, 0, 0x3, 1, 6}, // two bits 6-7
{"B02", 3, bt_num, LST, 0, 0, 0x7, 1, 0}, // three bits 0-2
{"B13", 3, bt_num, LST, 0, 0, 0x7, 1, 1}, // three bits 1-3
{"B24", 3, bt_num, LST, 0, 0, 0x7, 1, 2}, // three bits 2-4
{"B35", 3, bt_num, LST, 0, 0, 0x7, 1, 3}, // three bits 3-5
{"B46", 3, bt_num, LST, 0, 0, 0x7, 1, 4}, // three bits 4-6
{"B57", 3, bt_num, LST, 0, 0, 0x7, 1, 5}, // three bits 5-7
{"B03", 4, bt_num, LST, 0, 0, 0xf, 1, 0}, // four bits 0-3
{"B14", 4, bt_num, LST, 0, 0, 0xf, 1, 1}, // four bits 1-4
{"B25", 4, bt_num, LST, 0, 0, 0xf, 1, 2}, // four bits 2-5
{"B36", 4, bt_num, LST, 0, 0, 0xf, 1, 3}, // four bits 3-6
{"B47", 4, bt_num, LST, 0, 0, 0xf, 1, 4}, // four bits 4-7
{"B04", 5, bt_num, LST, 0, 0, 0x1f, 1, 0}, // five bits 0-4
{"B15", 5, bt_num, LST, 0, 0, 0x1f, 1, 1}, // five bits 1-5
{"B26", 5, bt_num, LST, 0, 0, 0x1f, 1, 2}, // five bits 2-6
{"B37", 5, bt_num, LST, 0, 0, 0x1f, 1, 3}, // five bits 3-7
{"B05", 6, bt_num, LST, 0, 0, 0x3f, 1, 0}, // six bits 0-5
{"B16", 6, bt_num, LST, 0, 0, 0x3f, 1, 1}, // six bits 1-6
{"B27", 6, bt_num, LST, 0, 0, 0x3f, 1, 2}, // six bits 2-7
{"B06", 7, bt_num, LST, 0, 0, 0x7f, 1, 0}, // seven bits 0-6
{"B17", 7, bt_num, LST, 0, 0, 0x7f, 1, 1}, // seven bits 1-7
};
/** the week day names. */
@@ -63,69 +101,55 @@ static const char* dayNames[] = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
#define VALUE_SEPARATOR ','
#define NULL_VALUE "-"
result_t DataField::create(const unsigned char dstAddress, const bool isSetMessage,
std::vector<std::string>::iterator& it, const std::vector<std::string>::iterator end,
const std::map<std::string, DataField*> predefined, std::vector<DataField*>& fields,
unsigned char& nextPos) {
std::string name, unit, comment;
result_t DataField::create(std::vector<std::string>::iterator& it, const std::vector<std::string>::iterator end,
const std::map<std::string, DataField*> templates, std::vector<DataField*>& fields,
const bool isSetMessage, const unsigned char dstAddress) {
std::string unit, comment;
PartType partType;
unsigned int divisor;
unsigned char baseOffset, offset, length, maxPos = 16, offsetCnt = 0;
unsigned int divisor = 0;
unsigned char offset, length, maxPos = 16, offsetCnt = 0;
const bool isTemplate = dstAddress == SYN;
std::string token;
if (it == end)
return RESULT_ERR_EOF;
name = *it++;
// name;[pos];type[;[divisor|values][;[unit][;[comment]]]]
const std::string name = *it++;
if (it == end || name.empty() == true)
return RESULT_ERR_EOF;
const char* posStr = (*it++).c_str();
if (it == end) {
// no more input: check for reference to predefined type
if (posStr[0] == 0)
return RESULT_ERR_EOF;
if (it == end)
return RESULT_ERR_EOF;
std::map<std::string, DataField*>::const_iterator ref = predefined.find(name);
if (ref != predefined.end()) {
fields.push_back(ref->second);
return RESULT_OK;
}
// check for sequence of reference to predefined type
std::istringstream stream(name);
while (std::getline(stream, token, VALUE_SEPARATOR) != 0) {
ref = predefined.find(token);
if (ref == predefined.end())
return RESULT_ERR_INVALID_ARG;
fields.push_back(ref->second);
}
return RESULT_OK;
}
if (dstAddress == BROADCAST
|| isMaster(dstAddress)
|| (isSetMessage == true && posStr[0] <= '9')
if (dstAddress == BROADCAST || isMaster(dstAddress)
|| (isTemplate == false && isSetMessage == true && posStr[0] != 0 && posStr[0] <= '9')
|| posStr[0] == 'm') { // master data
partType = pt_masterData;
baseOffset = 5; // skip QQ ZZ PB SB NN
if (posStr[0] == 'm')
posStr++;
} else if ((isSetMessage == false && posStr[0] <= '9')
} else if ((isTemplate == false && isSetMessage == false && posStr[0] != 0 && posStr[0] <= '9')
|| posStr[0] == 's') { // slave data
partType = pt_slaveData;
baseOffset = 1;
if (posStr[0] == 's')
posStr++;
} else if (isTemplate) {
partType = pt_template;
} else
return RESULT_ERR_INVALID_ARG;
bool hasPrev = fields.empty() == false;
if (hasPrev == true) {
DataField* previous = fields.back();
offset = previous->m_offset + previous->m_length;
if ((previous->m_dataType.numBits % 8) != 0
&& previous->m_dataType.precisionOrFirstBit + (previous->m_dataType.numBits % 8) < 8)
offset--; // previous bits not yet fully consumed
}
else
offset = 0;
if (posStr[0] == 0) {
if (nextPos == 0)
offset = baseOffset;
else if (nextPos < baseOffset)
return RESULT_ERR_INVALID_ARG; // missing pos definition
else
offset = nextPos;
length = 0;
} else {
offset = 0;
@@ -141,49 +165,46 @@ result_t DataField::create(const unsigned char dstAddress, const bool isSetMessa
if (end != start+strlen(start))
return RESULT_ERR_INVALID_ARG; // invalid pos definition
if (baseOffset+pos > maxPos)
if (pos > maxPos) // TODO check this in real offset as well
return RESULT_ERR_INVALID_ARG; // invalid pos definition
if (offsetCnt==1)
offset = baseOffset+pos;
else if (baseOffset+pos >= offset)
length = baseOffset+pos+1-offset;
offset = pos;
else if (pos >= offset)
length = pos+1-offset;
else { // wrong order e.g. 4-3
length = offset-(baseOffset+pos+1);
offset = baseOffset+pos;
length = offset-(pos+1);
offset = pos;
}
}
if (offset < baseOffset)
return RESULT_ERR_INVALID_ARG; //invalid pos definition
}
const char* typeStr = (*it++).c_str();
if (typeStr[0] == 0)
return RESULT_ERR_EOF;
std::map<unsigned int, std::string> values;
if (it == end)
divisor = 1;
else {
if (it != end) {
std::string divisorStr = *it++;
if (divisorStr.empty() == true)
divisor = 1;
else if (divisorStr.find_first_not_of("0123456789") == std::string::npos) {
const char* start = divisorStr.c_str();
char* end = NULL;
divisor = strtoul(start, &end, 10);
if (end != start+strlen(start))
return RESULT_ERR_INVALID_ARG;
}
else {
divisor = 1;
std::istringstream stream(divisorStr);
while (std::getline(stream, token, VALUE_SEPARATOR) != 0) {
const char* start = token.c_str();
if (divisorStr.empty() == false) {
if (divisorStr.find_first_not_of("0123456789") == std::string::npos) {
const char* start = divisorStr.c_str();
char* end = NULL;
unsigned int id = strtoul(start, &end, 10);
if (end == NULL || end == start || *end != '=')
divisor = strtoul(start, &end, 10);
if (end != start+strlen(start))
return RESULT_ERR_INVALID_ARG;
}
else {
std::istringstream stream(divisorStr);
while (std::getline(stream, token, VALUE_SEPARATOR) != 0) {
const char* start = token.c_str();
char* end = NULL;
unsigned int id = strtoul(start, &end, 10);
if (end == NULL || end == start || *end != '=')
return RESULT_ERR_INVALID_ARG;
values[id] = std::string(end+1);
values[id] = std::string(end+1);
}
}
}
}
@@ -204,19 +225,50 @@ result_t DataField::create(const unsigned char dstAddress, const bool isSetMessa
if (comment.length() == 1 && comment[0] == '-')
comment.clear();
}
//TODO derive more specific subtypes
// check for reference(s) to templates
if (templates.empty() == false) {
std::istringstream stream(typeStr);
bool found = false;
while (std::getline(stream, token, VALUE_SEPARATOR) != 0) {
std::map<std::string, DataField*>::const_iterator ref = templates.find(token);
if (ref == templates.end()) {
if (found == false)
break; // fallback to direct definition
return RESULT_ERR_INVALID_ARG; // cannot mix reference and direct definition
}
found = true;
DataField* templ = ref->second;
dataType_t dataType = templ->m_dataType;
unsigned char numBytes = (dataType.numBits+7)/8;
if (length != 0 && length != templ->m_length)
return RESULT_ERR_INVALID_ARG; // different length not possible for derivation
unsigned char deriveOffset = offset == 0 ? templ->m_offset : offset;
if (templ->m_partType != pt_template && partType == pt_template)
return RESULT_ERR_INVALID_ARG;
DataField* field = templ->derive(name, partType, deriveOffset, unit, comment, divisor, values);
if (field == NULL)
return RESULT_ERR_INVALID_ARG; // non-supported type for derivation or invalid argument
fields.push_back(field);
}
if (found == true)
return RESULT_OK;
}
for (size_t i = 0; i < sizeof(dataTypes)/sizeof(dataTypes[0]); i++) {
dataType_t dataType = dataTypes[i];
if (strcasecmp(typeStr, dataType.name) == 0) {
unsigned char numBytes = (dataType.numBits+7)/8;
unsigned char useLength = length;
if ((dataType.flags&ADJ) != 0) {
if (length == 0)
length = 1; // minimum length defaults to 1
else if (length > dataType.numBytes)
if (useLength == 0)
useLength = 1; // minimum length defaults to 1
else if (useLength > numBytes)
return RESULT_ERR_INVALID_ARG; // invalid length
}
else if (length == 0)
length = dataType.numBytes;
else if (length != dataType.numBytes)
else if (useLength == 0)
useLength = numBytes;
else if (useLength != numBytes)
continue; // check for another one with same name but different length
switch (dataType.type) {
@@ -224,8 +276,7 @@ result_t DataField::create(const unsigned char dstAddress, const bool isSetMessa
case bt_hexstr:
case bt_dat:
case bt_tim:
fields.push_back(new StringDataField(name, partType, offset, length, dataType, unit, comment));
nextPos = offset+length;
fields.push_back(new StringDataField(name, partType, offset, useLength, dataType, unit, comment));
return RESULT_OK;
case bt_num:
if (values.empty() == true && (dataType.flags&DAY) != 0) {
@@ -233,18 +284,17 @@ result_t DataField::create(const unsigned char dstAddress, const bool isSetMessa
values[dataType.minValueOrLength + i] = dayNames[i];
}
if (values.empty() == true || (dataType.flags&LST) == 0) {
fields.push_back(new NumberDataField(name, partType, offset, length, dataType, unit, comment, divisor));
nextPos = offset+length;
if (divisor == 0) {
divisor = dataType.divisor;
} else
divisor *= dataType.divisor;
fields.push_back(new NumberDataField(name, partType, offset, useLength, dataType, unit, comment, divisor));
return RESULT_OK;
}
if (values.begin()->first < dataType.minValueOrLength)
if (values.begin()->first < dataType.minValueOrLength
|| values.rbegin()->first > dataType.maxValueOrLength)
return RESULT_ERR_INVALID_ARG;
std::map<unsigned int, std::string>::iterator end = values.end();
end--;
if (end->first > dataType.maxValueOrLength)
return RESULT_ERR_INVALID_ARG;
fields.push_back(new ValueListDataField(name, partType, offset, length, dataType, unit, comment, values));
nextPos = offset+length;
fields.push_back(new ValueListDataField(name, partType, offset, useLength, dataType, unit, comment, values));
return RESULT_OK;
}
}
@@ -255,18 +305,22 @@ result_t DataField::create(const unsigned char dstAddress, const bool isSetMessa
result_t DataField::read(SymbolString& masterData, SymbolString& slaveData, std::ostringstream& output, bool verbose)
{
SymbolString& input = m_partType == pt_masterData ? masterData : slaveData;
unsigned char baseOffset;
switch (m_partType) {
case pt_masterData:
baseOffset = 5; // skip QQ ZZ PB SB NN
break;
case pt_slaveData:
baseOffset = 1; // skip NN
break;
default:
return RESULT_ERR_INVALID_ARG; // invalid part type
}
if (verbose)
output << m_name << "=";
result_t result = readSymbols(input, output);
result_t result = readSymbols(input, baseOffset, output);
if (result != RESULT_OK)
return result;
@@ -278,29 +332,42 @@ result_t DataField::read(SymbolString& masterData, SymbolString& slaveData, std:
return RESULT_OK;
}
result_t DataField::write(const std::string& value, SymbolString& masterData, SymbolString& slaveData)
result_t DataField::write(std::istringstream& input, SymbolString& masterData, SymbolString& slaveData)
{
SymbolString& output = m_partType == pt_masterData ? masterData : slaveData;
unsigned char baseOffset;
switch (m_partType) {
case pt_masterData:
baseOffset = 5; // skip QQ ZZ PB SB NN
break;
case pt_slaveData:
baseOffset = 1; // skip NN
break;
default:
return RESULT_ERR_INVALID_ARG;
}
std::istringstream input(value);
return writeSymbols(input, output);
return writeSymbols(input, baseOffset, output);
}
result_t StringDataField::readSymbols(SymbolString& input, std::ostringstream& output)
DataField* StringDataField::derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values) {
if (unit.empty() == true)
unit = m_unit;
if (comment.empty() == true)
comment = m_comment;
return new StringDataField(name, partType, offset, m_length, m_dataType, unit, comment);
}
result_t StringDataField::readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output)
{
size_t start = m_offset, end = m_offset + m_length;
int incr = 1;
unsigned char ch;
if (end > input.size())
if (baseOffset + end > input.size())
return RESULT_ERR_INVALID_ARG;
if ((m_dataType.flags&REV) != 0) { // reverted binary representation (most significant byte first)
@@ -309,10 +376,10 @@ result_t StringDataField::readSymbols(SymbolString& input, std::ostringstream& o
incr = -1;
}
for (size_t pos = start, i = 0; pos != end; pos += incr, i++) {
for (size_t offset = start, i = 0; offset != end; offset += incr, i++) {
if (m_length == 4 && i == 2 && m_dataType.type == bt_dat)
continue; // skip weekday in between
ch = input[pos];
ch = input[baseOffset + offset];
if ((m_dataType.flags & BCD) != 0) {
if ((ch & 0xf0) > 0x90 || (ch & 0x0f) > 0x09)
return RESULT_ERR_INVALID_ARG; // invalid BCD
@@ -337,7 +404,7 @@ result_t StringDataField::readSymbols(SymbolString& input, std::ostringstream& o
if (m_length == 1) { // truncated time
if (i == 0) {
ch /= 6; // hours
pos -= incr; // repeat for minutes
offset -= incr; // repeat for minutes
}
else
ch = (ch%6) * 10; // minutes
@@ -359,7 +426,7 @@ result_t StringDataField::readSymbols(SymbolString& input, std::ostringstream& o
return RESULT_OK;
}
result_t StringDataField::writeSymbols(std::istringstream& input, SymbolString& output)
result_t StringDataField::writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output)
{
size_t start = m_offset, end = m_offset + m_length;
int incr = 1;
@@ -374,7 +441,8 @@ result_t StringDataField::writeSymbols(std::istringstream& input, SymbolString&
incr = -1;
}
for (size_t pos = start, i = 0; pos != end; pos += incr, i++) {
size_t i = 0;
for (size_t offset = start; offset != end; offset += incr, i++) {
switch (m_dataType.type) {
case bt_hexstr:
while (input.peek()==' ')
@@ -424,7 +492,7 @@ result_t StringDataField::writeSymbols(std::istringstream& input, SymbolString&
return RESULT_ERR_INVALID_ARG; // invalid time part
if (m_length == 1) { // truncated time
if (i == 0) {
pos -= incr; // repeat for minutes
offset -= incr; // repeat for minutes
hours = value;
continue;
}
@@ -448,20 +516,23 @@ result_t StringDataField::writeSymbols(std::istringstream& input, SymbolString&
}
if (value > 0xff)
return RESULT_ERR_INVALID_ARG; // value out of range
output[pos] = (unsigned char)value;
output[baseOffset + offset] = (unsigned char)value;
}
if (i < m_length)
return RESULT_ERR_INVALID_ARG; // input too short
return RESULT_OK;
}
result_t NumericDataField::readRawValue(SymbolString& input, unsigned int& value)
result_t NumericDataField::readRawValue(SymbolString& input, unsigned char baseOffset, unsigned int& value)
{
size_t start = m_offset, end = m_offset + m_length;
int incr = 1;
unsigned char ch;
if (end > input.size())
if (baseOffset + end > input.size())
return RESULT_ERR_INVALID_ARG; // not enough data available
if ((m_dataType.flags&REV) != 0) { // reverted binary representation (most significant byte first)
@@ -471,8 +542,8 @@ result_t NumericDataField::readRawValue(SymbolString& input, unsigned int& value
}
value = 0;
for (size_t pos = start, exp = 1; pos != end; pos += incr) {
ch = input[pos];
for (size_t offset = start, exp = 1; offset != end; offset += incr) {
ch = input[baseOffset + offset];
if ((m_dataType.flags & BCD) != 0) {
if (ch == m_dataType.replacement) {
value = m_dataType.replacement;
@@ -483,17 +554,23 @@ result_t NumericDataField::readRawValue(SymbolString& input, unsigned int& value
ch = (ch >> 4) * 10 + (ch & 0x0f);
value += ch*exp;
exp = exp*100;
exp *= 100;
}
else {
value |= ch*exp;
exp = exp<<8;
exp <<= 8;
}
}
if ((m_dataType.flags & BCD) == 0) {
value >>= m_bitOffset;
if ((m_dataType.numBits%8) != 0)
value &= (1<<m_dataType.numBits)-1;
}
return RESULT_OK;
}
result_t NumericDataField::writeRawValue(unsigned int value, SymbolString& output)
result_t NumericDataField::writeRawValue(unsigned int value, unsigned char baseOffset, SymbolString& output)
{
size_t start = m_offset, end = m_offset + m_length;
int incr = 1;
@@ -505,7 +582,12 @@ result_t NumericDataField::writeRawValue(unsigned int value, SymbolString& outpu
incr = -1;
}
for (size_t pos = start, exp = 1; pos != end; pos += incr) {
if ((m_dataType.flags & BCD) == 0) {
if ((m_dataType.numBits%8) != 0)
value &= (1<<m_dataType.numBits)-1;
value <<= m_bitOffset;
}
for (size_t offset = start, exp = 1; offset != end; offset += incr) {
if ((m_dataType.flags & BCD) != 0) {
if (value == m_dataType.replacement)
ch = m_dataType.replacement;
@@ -519,19 +601,36 @@ result_t NumericDataField::writeRawValue(unsigned int value, SymbolString& outpu
ch = (value/exp)&0xff;
exp = exp<<8;
}
output[pos] = ch;
if (offset == start && (m_dataType.numBits%8) != 0 && baseOffset + offset < output.size())
output[baseOffset + offset] |= ch;
else
output[baseOffset + offset] = ch;
}
return RESULT_OK;
}
result_t NumberDataField::readSymbols(SymbolString& input, std::ostringstream& output)
DataField* NumberDataField::derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values) {
if (unit.empty() == true)
unit = m_unit;
if (comment.empty() == true)
comment = m_comment;
if (divisor == 0)
divisor = m_divisor;
else
divisor *= m_dataType.divisor;
return new NumberDataField(name, partType, offset, m_length, m_dataType, unit, comment, divisor);
}
result_t NumberDataField::readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output)
{
unsigned int value = 0;
int signedValue;
result_t result = readRawValue(input, value);
result_t result = readRawValue(input, baseOffset, value);
if (result != RESULT_OK)
return result;
@@ -539,65 +638,70 @@ result_t NumberDataField::readSymbols(SymbolString& input, std::ostringstream& o
output << NULL_VALUE;
return RESULT_OK;
}
bool negative = (m_dataType.flags&SIG) != 0 && (value & (1 << (m_dataType.numBytes*8 - 1))) != 0;
if (m_dataType.numBytes == 4) {
bool negative = (m_dataType.flags&SIG) != 0 && (value & (1 << (m_dataType.numBits - 1))) != 0;
if (m_dataType.numBits == 32) {
if (negative == false) {
if (m_divisor <= 1)
output << static_cast<unsigned>(value);
else
output << std::setprecision(3) << std::fixed << static_cast<float>(value / (float)m_divisor);
output << std::setprecision((m_dataType.numBits%8)==0 ? m_dataType.precisionOrFirstBit : 0)
<< std::fixed << static_cast<float>(value / (float)m_divisor);
return RESULT_OK;
}
signedValue = (int)value; // negative signed value
}
else
if (negative) // negative signed value
signedValue = (int)value - (1 << (m_dataType.numBytes*8));
signedValue = (int)value - (1 << m_dataType.numBits);
else
signedValue = (int)value;
if (m_divisor <= 1)
output << static_cast<int>(signedValue);
else
output << std::setprecision(3) << std::fixed << static_cast<float>(signedValue / (float)m_divisor);
output << std::setprecision((m_dataType.numBits%8)==0 ? m_dataType.precisionOrFirstBit : 0)
<< std::fixed << static_cast<float>(signedValue / (float)m_divisor);
return RESULT_OK;
}
result_t NumberDataField::writeSymbols(std::istringstream& input, SymbolString& output)
result_t NumberDataField::writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output)
{
unsigned int value;
const char* str = input.str().c_str();
size_t len = strlen(str);
if (strcasecmp(str, NULL_VALUE) == 0)
// replacement value
value = m_dataType.replacement;
else if (len == 0)
return RESULT_ERR_INVALID_ARG; // input too short
else {
char* strEnd = NULL;
if (m_divisor <= 1) {
if ((m_dataType.flags&SIG) != 0) {
int signedValue = strtol(str, &strEnd, 10);
if (signedValue < 0 && m_dataType.numBytes != 4)
value = (unsigned int)(signedValue + (1<<(m_dataType.numBytes*8)));
if (signedValue < 0 && m_dataType.numBits != 32)
value = (unsigned int)(signedValue + (1<<m_dataType.numBits));
else
value = (unsigned int)signedValue;
}
else
value = strtoul(str, &strEnd, 10);
if (strEnd != str+strlen(str))
if (strEnd != str+len)
return RESULT_ERR_INVALID_ARG; // invalid value
}
else {
char* strEnd = NULL;
double dvalue = strtod(str, &strEnd);
if (strEnd != str+strlen(str))
if (strEnd != str+len)
return RESULT_ERR_INVALID_ARG; // invalid value
dvalue = dvalue * m_divisor + 0.5; // round
dvalue = round(dvalue * m_divisor);
if ((m_dataType.flags&SIG) != 0) {
if (dvalue < -(1LL<<(8*m_length)) || dvalue >= (1LL<<(8*m_length)))
return RESULT_ERR_INVALID_ARG; // value out of range
if (dvalue < 0 && m_dataType.numBytes != 4)
value = (unsigned int)(dvalue + (1<<(m_dataType.numBytes*8)));
if (dvalue < 0 && m_dataType.numBits != 32)
value = (unsigned int)(dvalue + (1<<m_dataType.numBits));
else
value = (unsigned int)dvalue;
}
@@ -609,7 +713,7 @@ result_t NumberDataField::writeSymbols(std::istringstream& input, SymbolString&
}
if ((m_dataType.flags&SIG) != 0) { // signed value
if ((value & (1 << (m_dataType.numBytes*8 - 1))) != 0) { // negative signed value
if ((value & (1 << (m_dataType.numBits - 1))) != 0) { // negative signed value
if (value < m_dataType.minValueOrLength)
return RESULT_ERR_INVALID_ARG; // value out of range
}
@@ -621,39 +725,59 @@ result_t NumberDataField::writeSymbols(std::istringstream& input, SymbolString&
}
return writeRawValue(value, output);
return writeRawValue(value, baseOffset, output);
}
result_t ValueListDataField::readSymbols(SymbolString& input, std::ostringstream& output)
DataField* ValueListDataField::derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values) {
if (unit.empty() == true)
unit = m_unit;
if (comment.empty() == true)
comment = m_comment;
if (values.empty() == true) {
values = m_values;
}
else if (values.begin()->first < m_dataType.minValueOrLength
|| values.rbegin()->first > m_dataType.maxValueOrLength)
return NULL;
return new ValueListDataField(name, partType, offset, m_length, m_dataType, unit, comment, values);
}
result_t ValueListDataField::readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output)
{
unsigned int value = 0;
result_t result = readRawValue(input, value);
result_t result = readRawValue(input, baseOffset, value);
if (result != RESULT_OK)
return result;
std::map<unsigned int, std::string>::iterator it = m_values.find(value);
if (it != m_values.end()) {
output << it->second;
return RESULT_OK;
}
if (value == m_dataType.replacement) {
output << NULL_VALUE;
return RESULT_OK;
}
std::map<unsigned int, std::string>::iterator it = m_values.find(value);
if (it == m_values.end())
return RESULT_ERR_INVALID_ARG; // value assignment not found
output << it->second;
return RESULT_OK;
return RESULT_ERR_INVALID_ARG; // value assignment not found
}
result_t ValueListDataField::writeSymbols(std::istringstream& input, SymbolString& output)
result_t ValueListDataField::writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output)
{
std::string str;
input >> str;
const char* str = input.str().c_str();
for (std::map<unsigned int, std::string>::iterator it = m_values.begin(); it != m_values.end(); it++)
if (it->second.compare(str) == 0)
return writeRawValue(it->first, output);
return writeRawValue(it->first, baseOffset, output);
if (strcasecmp(str, NULL_VALUE) == 0) // replacement value
return writeRawValue(m_dataType.replacement, baseOffset, output);
return RESULT_ERR_INVALID_ARG; // value assignment not found
}
src/lib/ebus/data.h
+59 -38
View File
@@ -32,6 +32,7 @@ namespace libebus
/** the message part in which a data field is stored. */
enum PartType {
pt_template, // special part type for templates (relative offset)
pt_masterData, // stored in master data
pt_slaveData, // stored in slave data
};
@@ -46,23 +47,24 @@ enum BaseType {
};
/** flags for dataType_t. */
const unsigned int ADJ = 0x01; // adjustable length, numBytes is maximum length
const unsigned int ADJ = 0x01; // adjustable length, numBits is maximum length
const unsigned int BCD = 0x02; // binary representation is BCD
const unsigned int REV = 0x04; // reverted binary representation (most significant byte first)
const unsigned int SIG = 0x08; // signed value
const unsigned int LST = 0x10; // value list is possible (without applied divisor)
const unsigned int DAY = 0x20; // default value list is week days
const unsigned int DAY = 0x20; // forced value list defaulting to week days
/** the structure for defining field types with their properties. */
typedef struct {
const char* name; // field identifier
const unsigned int numBytes; // number of bytes (maximum length if ADJ flag is set)
const BaseType type; // base data type
const unsigned int flags; // flags (e.g. BCD)
const unsigned int replacement; // replacement value (fill-up value for bt_str/bt_hexstr)
const unsigned int minValueOrLength; // minimum binary value (minimum length of string for StringDataField)
const unsigned int maxValueOrLength; // maximum binary value (maximum length of string for StringDataField)
const unsigned int divisor; // divisor for bt_number values (or 0 for non-numeric)
const char* name; // field identifier
const unsigned int numBits; // number of bits (maximum length if ADJ flag is set, must be multiple of 8 with flag BCD)
const BaseType type; // base data type
const unsigned int flags; // flags (e.g. BCD)
const unsigned int replacement; // replacement value (fill-up value for bt_str/bt_hexstr, no replacement if equal to minValueOrLength for bt_num)
const unsigned int minValueOrLength; // minimum binary value (minimum length of string for StringDataField)
const unsigned int maxValueOrLength; // maximum binary value (maximum length of string for StringDataField)
const unsigned int divisor; // bt_number: divisor
const unsigned char precisionOrFirstBit; // bt_number: precision for formatting or offset to first bit if (numBits%8)!=0
} dataType_t;
@@ -76,7 +78,7 @@ public:
* @brief Constructs a new instance.
* @param name the field name.
* @param partType the message part in which the field is stored.
* @param offset the offset to the first symbol in the message part in which the field is stored.
* @param offset the relatvie offset to the first symbol in the message part in which the field is stored.
* @param length the number of symbols in the message part in which the field is stored.
* @param dataType the data type definition.
* @param unit the value unit.
@@ -95,21 +97,19 @@ public:
virtual ~DataField() {}
/**
* @brief Factory method for creating a new instance.
* @param dstAddress the destination bus address.
* @param isSetMessage whether the field is part of a set message.
* @brief Factory method for creating new instances.
* @param it the iterator to traverse for the definition parts.
* @param end the iterator pointing to the end of the definition parts.
* @param predefined a map of predefined DataFields to be referenced by name.
* @param templates a map of DataField templates to be referenced by name.
* @param fields the vector to which created instances are added.
* @param nextPos the variable holding the next subsequent position.
* @param isSetMessage whether the field is part of a set message (default false).
* @param dstAddress the destination bus address (default @a SYN for creating a template DataFields).
* @return RESULT_OK on success, RESULT_ERR_EOF if the iterator is empty, or an error code.
* Note: the caller needs to cleanup created instances.
*/
static result_t create(const unsigned char dstAddress, const bool isSetMessage,
std::vector<std::string>::iterator& it, const std::vector<std::string>::iterator end,
const std::map<std::string, DataField*> predefined, std::vector<DataField*>& fields,
unsigned char& nextPos);
static result_t create(std::vector<std::string>::iterator& it, const std::vector<std::string>::iterator end,
const std::map<std::string, DataField*> templates, std::vector<DataField*>& fields,
const bool isSetMessage=false, const unsigned char dstAddress=SYN);
/**
* @brief Reads the value from the master or slave @a SymbolString.
@@ -124,34 +124,42 @@ public:
bool verbose=false);
/**
* @brief Writes the value to the master or slave @a SymbolString.
* @param input the istringstream to parse the formatted value from.
* @param masterData the unescaped master data @a SymbolString for writing binary data.
* @param slaveData the unescaped slave data @a SymbolString for writing binary data.
* @param value the formatted value as string.
* @return RESULT_OK on success, or an error code.
*/
result_t write(const std::string& value, SymbolString& masterData, SymbolString& slaveData);
result_t write(std::istringstream& input, SymbolString& masterData, SymbolString& slaveData);
/**
* @brief Get the field name.
* @return the field name.
*/
const std::string getName() { return m_name; }
//TODO add getter for all fields
protected:
virtual DataField* derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values) = 0;
/**
* @brief Internal method for reading the field from a @a SymbolString.
* @param input the unescaped @a SymbolString to read the binary value from.
* @param output the ostringstream to append the formatted value to.
* @return RESULT_OK on success, or an error code.
*/
virtual result_t readSymbols(SymbolString& input, std::ostringstream& output) = 0;
virtual result_t readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output) = 0;
/**
* @brief Internal method for writing the field to a @a SymbolString.
* @param input the istringstream to parse the formatted value from.
* @param output the unescaped @a SymbolString to write the binary value to.
* @return RESULT_OK on success, or an error code.
*/
virtual result_t writeSymbols(std::istringstream& input, SymbolString& output) = 0;
virtual result_t writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output) = 0;
/** the field name. */
const std::string m_name;
/** the message part in which the field is stored. */
const PartType m_partType;
/** the offset to the first symbol in the message part in which the field is stored. */
/** the relative offset to the first symbol in the message part in which the field is stored. */
const unsigned char m_offset;
/** the number of symbols in the message part in which the field is stored. */
const unsigned char m_length;
@@ -191,8 +199,10 @@ public:
virtual ~StringDataField() {}
protected:
virtual result_t readSymbols(SymbolString& input, std::ostringstream& output);
virtual result_t writeSymbols(std::istringstream& input, SymbolString& output);
virtual DataField* derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values);
virtual result_t readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output);
virtual result_t writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output);
};
@@ -209,6 +219,7 @@ public:
* @param partType the message part in which the field is stored.
* @param offset the offset to the first symbol in the message part in which the field is stored.
* @param length the number of symbols in the message part in which the field is stored.
* @param bitOffset the offset to the first bit in the binary value.
* @param dataType the data type definition.
* @param unit the value unit.
* @param comment the field comment.
@@ -216,8 +227,9 @@ public:
NumericDataField(const std::string name, const PartType partType,
const unsigned char offset, const unsigned char length,
const dataType_t dataType, const std::string unit,
const std::string comment)
: DataField(name, partType, offset, length, dataType, unit, comment) {}
const std::string comment, const unsigned char bitOffset)
: DataField(name, partType, offset, length, dataType, unit, comment),
m_bitOffset(bitOffset) {}
/**
* @brief Destructor.
*/
@@ -230,14 +242,17 @@ protected:
* @param value the variable in which to store the raw value.
* @return RESULT_OK on success, or an error code.
*/
result_t readRawValue(SymbolString& input, unsigned int& value);
result_t readRawValue(SymbolString& input, unsigned char baseOffset, unsigned int& value);
/**
* @brief Internal method for writing the raw value to a @a SymbolString.
* @param value the raw value to write.
* @param output the unescaped @a SymbolString to write the binary value to.
* @return RESULT_OK on success, or an error code.
*/
result_t writeRawValue(unsigned int value, SymbolString& output);
result_t writeRawValue(unsigned int value, unsigned char baseOffset, SymbolString& output);
/** the offset to the first bit in the binary value. */
const unsigned char m_bitOffset;
};
@@ -262,16 +277,19 @@ public:
const unsigned char offset, const unsigned char length,
const dataType_t dataType, const std::string unit,
const std::string comment, const unsigned int divisor)
: NumericDataField(name, partType, offset, length, dataType, unit, comment),
m_divisor(divisor * dataType.divisor) {}
: NumericDataField(name, partType, offset, length, dataType, unit, comment,
(dataType.numBits%8) != 0 ? dataType.precisionOrFirstBit : 0),
m_divisor(divisor) {}
/**
* @brief Destructor.
*/
virtual ~NumberDataField() {}
protected:
virtual result_t readSymbols(SymbolString& input, std::ostringstream& output);
virtual result_t writeSymbols(std::istringstream& input, SymbolString& output);
virtual DataField* derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values);
virtual result_t readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output);
virtual result_t writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output);
/** the combined divisor to apply on the value, or 1 for none. */
const unsigned int m_divisor;
@@ -299,7 +317,8 @@ public:
const unsigned char offset, const unsigned char length,
const dataType_t dataType, const std::string unit,
const std::string comment, const std::map<unsigned int, std::string> values)
: NumericDataField(name, partType, offset, length, dataType, unit, comment),
:NumericDataField(name, partType, offset, length, dataType, unit, comment,
(dataType.numBits%8) != 0 ? dataType.precisionOrFirstBit : 0),
m_values(values) {}
/**
* @brief Destructor.
@@ -307,8 +326,10 @@ public:
virtual ~ValueListDataField() {}
protected:
virtual result_t readSymbols(SymbolString& input, std::ostringstream& output);
virtual result_t writeSymbols(std::istringstream& input, SymbolString& output);
virtual DataField* derive(std::string name, PartType partType, unsigned char offset, std::string unit,
std::string comment, unsigned int divisor, std::map<unsigned int, std::string> values);
virtual result_t readSymbols(SymbolString& input, unsigned char baseOffset, std::ostringstream& output);
virtual result_t writeSymbols(std::istringstream& input, unsigned char baseOffset, SymbolString& output);
/** the value=text assignments. */
std::map<unsigned int, std::string> m_values;
src/lib/ebus/test/test_data.cpp
+237 -84
View File
@@ -23,116 +23,269 @@
using namespace libebus;
void verify(bool expectFailMatch, std::string type, std::string input, bool match, std::string expectStr, std::string gotStr) {
if (expectFailMatch == true) {
if (match == true)
std::cout << " failed " << type << " match >" << input << "< error: unexpectedly succeeded" << std::endl;
else
std::cout << " failed " << type << " match >" << input << "< OK" << std::endl;
} else if (match == true)
std::cout << " " << type << " >" << input << "< OK" << std::endl;
else
std::cout << " " << type << " >" << input << "< error: got >" << gotStr
<< "<, expected >" << expectStr << "<" << std::endl;
}
int main ()
{
std::string checks[][4] = {
//name;position(s);type;factor;unit;comment
// {"temp;1;d2b;;°C;Aussentemperatur","temp=18.004 °C [Aussentemperatur]","10fe070009019258042126100714cc", "00"},
// {"zeit;1;ttm;2;Uhr;","zeit=22:40 Uhr","10feffff0188", "00"},
{"x;1-10;hex","53 70 65 69 63 68 65 72 20 20", "10fe07000a53706569636865722020", "00"},
{"x;;bti","21:04:58","10fe070009580421", "00"},
{"x;;bda","26.10.2014","10fe07000926100714", "00"},
{"x;1-3;bda","26.10.2014","10fe070003261014", "00"},
{"x;;hdy","Sun","10fe07000307", "00"},
{"x;;bdy","Sun","10fe07000306", "00"},
{"x;;d2b","18.004","10fe0700090112", "00"},
{"x;;d2c","288.062","10fe0700090112", "00"},
{"x;;ttm","22:40","10feffff0188", "00"},
{"x;;bcd","26","10feffff0126", "00"},
{"x;;bcd","-","10feffff01ff", "00"},
{"x;;uch","38","10feffff0126", "00"},
{"x;;sch","-90","10feffff01a6", "00"},
{"x;;d1b","-90","10feffff01a6", "00"},
{"x;;d1c","19.500","10feffff0127", "00"},
{"x;;uin","38","10feffff022600", "00"},
{"x;;sin","-90","10feffff02a6ff", "00"},
{"x;;ulg","38","10feffff0426000000", "00"},
{"x;;slg","-90","10feffff04a6ffffff", "00"},
{"x;;flt","-0.090","10feffff02a6ff", "00"},
{"x;1-9;str","hallo Du!","10feffff0868616c6c6f20447521", "00"},
{"x;1-9;str","hallo Du ","10feffff0868616c6c6f20447520", "00"},
{"new;1;uch;1=test,2=high,3=off,4=on","on","10feffff0104", "00"},
std::string checks[][5] = {
//name;[pos];type[;[divisor|values][;[unit][;[comment]]]], decoded value, master, slave, flags
{"x;1-10;str", "Hallo, Du!", "10fe07000a48616c6c6f2c20447521", "00", ""},
{"x;1-10;str", "Hallo, Du ", "10fe07000a48616c6c6f2c20447520", "00", ""},
{"x;1-10;str", " ", "10fe07000a20202020202020202020", "00", ""},
{"x;1-11;str", "", "10fe07000a20202020202020202020", "00", "rW"},
{"x;;hex", "20", "10fe07000120", "00", ""},
{"x;1-10;hex", "48 61 6c 6c 6f 2c 20 44 75 21", "10fe07000a48616c6c6f2c20447521", "00", ""},
{"x;1-11;hex", "", "10fe07000a48616c6c6f2c20447521", "00", "rW"},
{"x;;bda", "26.10.2014","10fe07000426100014", "00", ""},
{"x;;bda", "01.01.2000","10fe07000401010000", "00", ""},
{"x;;bda", "31.12.2099","10fe07000431120099", "00", ""},
{"x;;bda", "", "10fe07000432100014", "00", "rw"},
{"x;1-3;bda","26.10.2014","10fe070003261014", "00", ""},
{"x;1-3;bda","01.01.2000","10fe070003010100", "00", ""},
{"x;1-3;bda","31.12.2099","10fe070003311299", "00", ""},
{"x;1-3;bda","", "10fe070003321299", "00", "rw"},
{"x;;bti", "21:04:58", "10fe070003580421", "00", ""},
{"x;;bti", "00:00:00", "10fe070003000000", "00", ""},
{"x;;bti", "23:59:59", "10fe070003595923", "00", ""},
{"x;;bti", "", "10fe070003605923", "00", "rw"},
{"x;;htm", "21:04", "10fe0700021504", "00", ""},
{"x;;htm", "00:00", "10fe0700020000", "00", ""},
{"x;;htm", "23:59", "10fe070002173b", "00", ""},
{"x;;htm", "", "10fe070002183b", "00", "rw"},
{"x;;htm", "24:00", "10fe070002173b", "00", "Rw"},
{"x;;ttm", "22:40", "10fe07000188", "00", ""},
{"x;;ttm", "00:00", "10fe07000100", "00", ""},
{"x;;ttm", "23:50", "10fe0700018f", "00", ""},
{"x;;ttm", "24:00", "10fe07000190", "00", "rw"}, // TODO check range
{"x;;ttm", "", "10fe07000191", "00", "rw"}, // TODO check range
{"x;;bdy", "Mon", "10fe07000300", "00", ""},
{"x;;bdy", "Sun", "10fe07000306", "00", ""},
{"x;;bdy", "", "10fe07000308", "00", "rw"},
{"x;;hdy", "Mon", "10fe07000301", "00", ""},
{"x;;hdy", "Sun", "10fe07000307", "00", ""},
{"x;;hdy", "", "10fe07000308", "00", "rw"},
{"x;;bcd", "26", "10feffff0126", "00", ""},
{"x;;bcd", "0", "10feffff0100", "00", ""},
{"x;;bcd", "99", "10feffff0199", "00", ""},
{"x;;bcd", "-", "10feffff01ff", "00", ""},
{"x;;bcd", "", "10feffff019a", "00", "rw"},
{"x;;uch", "38", "10feffff0126", "00", ""},
{"x;;uch", "0", "10feffff0100", "00", ""},
{"x;;uch", "254", "10feffff01fe", "00", ""},
{"x;;uch", "-", "10feffff01ff", "00", ""},
{"x;;sch", "-90", "10feffff01a6", "00", ""},
{"x;;sch", "0", "10feffff0100", "00", ""},
{"x;;sch", "-1", "10feffff01ff", "00", ""},
{"x;;sch", "-", "10feffff0180", "00", ""},
{"x;;sch", "-127", "10feffff0181", "00", ""},
{"x;;sch", "127", "10feffff017f", "00", ""},
{"x;;d1b", "-90", "10feffff01a6", "00", ""},
{"x;;d1b", "0", "10feffff0100", "00", ""},
{"x;;d1b", "-1", "10feffff01ff", "00", ""},
{"x;;d1b", "-", "10feffff0180", "00", ""},
{"x;;d1b", "-127", "10feffff0181", "00", ""},
{"x;;d1b", "127", "10feffff017f", "00", ""},
{"x;;d1c", "19.5", "10feffff0127", "00", ""},
{"x;;d1c", "0.0", "10feffff0100", "00", ""},
{"x;;d1c", "100.0", "10feffff01c8", "00", ""},
{"x;;d1c", "-", "10feffff01ff", "00", ""},
{"x;;uin", "38", "10feffff022600", "00", ""},
{"x;;uin", "0", "10feffff020000", "00", ""},
{"x;;uin", "65534", "10feffff02feff", "00", ""},
{"x;;uin", "-", "10feffff02ffff", "00", ""},
{"x;;sin", "-90", "10feffff02a6ff", "00", ""},
{"x;;sin", "0", "10feffff020000", "00", ""},
{"x;;sin", "-1", "10feffff02ffff", "00", ""},
{"x;;sin", "-", "10feffff020080", "00", ""},
{"x;;sin", "-32767", "10feffff020180", "00", ""},
{"x;;sin", "32767", "10feffff02ff7f", "00", ""},
{"x;;flt", "-0.090", "10feffff02a6ff", "00", ""},
{"x;;flt", "0.000", "10feffff020000", "00", ""},
{"x;;flt", "-0.001", "10feffff02ffff", "00", ""},
{"x;;flt", "-", "10feffff020080", "00", ""},
{"x;;flt","-32.767", "10feffff020180", "00", ""},
{"x;;flt", "32.767", "10feffff02ff7f", "00", ""},
{"x;;d2b", "18.004", "10fe0700090112", "00", ""},
{"x;;d2b", "0.000", "10feffff020000", "00", ""},
{"x;;d2b", "-0.004", "10feffff02ffff", "00", ""},
{"x;;d2b", "-", "10feffff020080", "00", ""},
{"x;;d2b","-127.996","10feffff020180", "00", ""},
{"x;;d2b", "127.996","10feffff02ff7f", "00", ""},
{"x;;d2c", "288.06", "10fe0700090112", "00", ""},
{"x;;d2c", "0.00", "10feffff020000", "00", ""},
{"x;;d2c", "-0.06", "10feffff02ffff", "00", ""},
{"x;;d2c", "-", "10feffff020080", "00", ""},
{"x;;d2c","-2047.94","10feffff020180", "00", ""},
{"x;;d2c", "2047.94","10feffff02ff7f", "00", ""},
{"x;;ulg", "38", "10feffff0426000000", "00", ""},
{"x;;ulg", "0", "10feffff0400000000", "00", ""},
{"x;;ulg", "4294967294", "10feffff04feffffff", "00", ""},
{"x;;ulg", "-", "10feffff04ffffffff", "00", ""},
{"x;;slg", "-90", "10feffff04a6ffffff", "00", ""},
{"x;;slg", "0", "10feffff0400000000", "00", ""},
{"x;;slg", "-1", "10feffff04ffffffff", "00", ""},
{"x;;bi3", "1", "10feffff0108", "00", ""},
{"x;;bi3", "-", "10feffff0100", "00", ""},
{"x;;bi3;0=off,1=on","on", "10feffff0108", "00", ""},
{"x;;bi3;0=off,1=on","off","10feffff0100", "00", ""},
{"x;;b34", "1", "10feffff0108", "00", ""},
{"x;;b34", "-", "10feffff0100", "00", ""},
{"x;;b34", "3", "10feffff0118", "00", ""},
{"x;;b34;1=on","on", "10feffff0108", "00", ""},
{"x;;b34;1=on","-", "10feffff0100", "00", ""},
{"x;;b34;0=off,1=on,2=auto,3=eco","auto", "10feffff0110", "00", ""},
{"x;;b34;0=off,1=on","on", "10feffff0108", "00", ""},
{"x;;b34;0=off,1=on","off","10feffff0100", "00", ""},
{"x;;uch;1=test,2=high,3=off,4=on","on","10feffff0104", "00", ""},
{"x;s3;uch","3","1050ffff00", "03000003", ""},
{"x;s3;uch","3","1050ffff00", "020000", "rW"},
{"x;;d2b;;°C;Aussentemperatur","x=18.004 °C [Aussentemperatur]","10fe0700090112", "00", "v"},
{"x;;bti;;;;y;;bda;;;;z;6;bdy", "21:04:58;26.10.2014;Sun","10fe07000758042126100614", "00", "c"},
//TODO test bit combinations
{"temprel;;d2b;;°C;Aussentemperatur","","", "", "p"}, // predefined type with relative pos
{"tempabs;1;d2b;;°C;Aussentemperatur","","", "", "p"},// predefined type with absolute pos
{"strucrelrel;;d2b;;;;y;;d1c","","", "", "p"}, // predefined combined type with relative pos
{"strucrelabs;;d2b;;;;y;1;d1c","","", "", "p"}, // predefined combined type with relative pos
{"strucabsrel;1;d2b;;;;y;;d1c","","", "", "p"}, // predefined combined type with relative pos
{"strucabsabs;2;d2b;;;;y;1;d1c","","", "", "p"}, // predefined combined type with absolute pos
{"x;;temprel","18.004","10fe0700090112", "00", ""}, // reference predefined type
{"strucrelrel;;temprel,temprel","","", "", "p"}, // predefined combined type with relative pos
{"strucrelabs;;temprel,tempabs","","", "", "p"}, // predefined combined type with relative pos
{"strucabsrel;1;tempabs,temprel","","", "", "p"}, // predefined combined type with relative pos
{"strucabs;2;tempabs","","", "", "p"}, // predefined combined type with absolute pos
};
std::map<std::string, DataField*> predefined;
std::map<std::string, DataField*> templates;
std::vector<DataField*> fields;
unsigned char nextPos;
for (size_t i = 0; i < sizeof(checks)/sizeof(checks[0]); i++) {
std::istringstream isstr(checks[i][0]);
std::string expectStr = checks[i][1];
SymbolString mstr = SymbolString(checks[i][2], false);
SymbolString sstr = SymbolString(checks[i][3], false);
std::string check[5] = checks[i];
std::istringstream isstr(check[0]);
std::string expectStr = check[1];
SymbolString mstr = SymbolString(check[2], false);
SymbolString sstr = SymbolString(check[3], false);
std::string flags = check[4];
bool isSet = flags.find('s') != std::string::npos;
bool failedRead = flags.find('r') != std::string::npos;
bool failedReadMatch = flags.find('R') != std::string::npos;
bool failedWrite = flags.find('w') != std::string::npos;
bool failedWriteMatch = flags.find('W') != std::string::npos;
bool verbose = flags.find('v') != std::string::npos;
bool combinedValue = flags.find('c') != std::string::npos;
bool isPredefine = flags.find('p') != std::string::npos;
std::string item;
std::vector<std::string> entries;
while (fields.empty() == false) {
delete fields.back();
fields.pop_back();
}
while (std::getline(isstr, item, ';') != 0)
entries.push_back(item);
std::vector<std::string>::iterator it = entries.begin();
nextPos = 0;
result_t result = DataField::create(mstr[1], false, it, entries.end(), predefined, fields, nextPos);
result_t result;
do {
result = DataField::create(it, entries.end(), templates, fields, isSet, isPredefine ? SYN : mstr[1]);
} while (result == RESULT_OK && it != entries.end());
if (result != RESULT_OK) {
std::cout << "create \"" << checks[i][0] << "\" failed: " << getResultCodeCStr(result) << std::endl;
std::cout << "\"" << check[0] << "\": create error: " << getResultCodeCStr(result) << std::endl;
continue;
}
if (fields.empty() == true) {
std::cout << "create \"" << checks[i][0] << "\" failed: empty" << std::endl;
std::cout << "\"" << check[0] << "\": create error: empty" << std::endl;
continue;
}
std::cout << "create \"" << checks[i][0] << "\" successful" << std::endl;
DataField* field = fields.back();
fields.pop_back();
std::ostringstream output;
result = field->read(mstr, sstr, output);
if (result != RESULT_OK) {
std::cout << "read \"" << checks[i][0] << "\" failed: " << getResultCodeCStr(result) << std::endl;
}
else {
std::string gotStr = output.str();
if (strcasecmp(gotStr.c_str(), expectStr.c_str()) == 0)
std::cout << "read successful: " << gotStr << std::endl;
else
std::cout << "read invalid: got " << gotStr
<< ", expected " << expectStr << std::endl;
SymbolString writeMstr = SymbolString(mstr.getDataStr().substr(0, 10), false);
SymbolString writeSstr = SymbolString(sstr.getDataStr().substr(0, 2), false);
if (result != RESULT_OK) {
std::cout << "create \"" << checks[i][0] << "\" failed: " << getResultCodeCStr(result) << std::endl;
return 1;
}
result = field->write(gotStr, writeMstr, writeSstr);
if (result != RESULT_OK) {
std::cout << "write \"" << checks[i][0] << "\" failed: " << getResultCodeCStr(result) << std::endl;
}
else {
if (mstr == writeMstr && sstr == writeSstr)
std::cout << "write successful" << std::endl;
std::cout << "\"" << check[0] << "\": create OK" << std::endl;
if (isPredefine) {
// store new template
while (fields.empty() == false) {
DataField* field = fields.front();
fields.erase(fields.begin());
std::map<std::string, DataField*>::iterator current = templates.find(field->getName());
if (current == templates.end())
templates[field->getName()] = field;
else {
std::cout << "write invalid: ";
if (mstr == writeMstr)
std::cout << "master OK";
else
std::cout << "master got " << writeMstr.getDataStr() << ", expected " << mstr.getDataStr();
if (sstr == writeSstr)
std::cout << ", slave OK";
else
std::cout << ", slave got " << writeSstr.getDataStr() << ", expected " << sstr.getDataStr();
std::cout << std::endl;
delete current->second;
current->second = field;
}
}
continue;
}
delete field;
std::ostringstream output;
std::istringstream input(expectStr);
SymbolString writeMstr = SymbolString(mstr.getDataStr().substr(0, 10), false);
SymbolString writeSstr = SymbolString(sstr.getDataStr().substr(0, 2), false);
bool first = true, failed = false;
while (fields.empty() == false) {
field = fields.back();
fields.pop_back();
delete field; // TODO use me
DataField* field = fields.front();
fields.erase(fields.begin());
if (first == false)
output << ";";
result = field->read(mstr, sstr, output, verbose);
if (failedRead == true)
if (result == RESULT_OK)
std::cout << " failed read " << field->getName() << " >" << check[2] << "< error: unexpectedly succeeded" << std::endl;
else
std::cout << " failed read " << field->getName() << " >" << check[2] << "< OK" << std::endl;
else if (result != RESULT_OK) {
std::cout << " read " << field->getName() << " >" << check[2] << "< error: " << getResultCodeCStr(result) << std::endl;
failed = true;
}
else if (combinedValue == false) {
bool match = strcasecmp(output.str().c_str(), expectStr.c_str()) == 0;
verify(failedReadMatch, "read", check[2], match, expectStr, output.str());
}
if (verbose == false) {
std::string token;
std::getline(input, token, ';');
std::istringstream tokeninput(token);
result = field->write(tokeninput, writeMstr, writeSstr);
if (failedWrite == true) {
if (result == RESULT_OK)
std::cout << " failed write " << field->getName() << " >" << expectStr << "< error: unexpectedly succeeded" << std::endl;
else
std::cout << " failed write " << field->getName() << " >" << expectStr << "< OK" << std::endl;
}
else if (result != RESULT_OK) {
std::cout << " write " << field->getName() << " >" << expectStr << "< error: " << getResultCodeCStr(result) << std::endl;
failed = true;
}
}
first = false;
}
if (combinedValue == true && failedRead == false && failed == false) {
bool match = strcasecmp(output.str().c_str(), expectStr.c_str()) == 0;
verify(failedReadMatch, "read", check[2], match, expectStr, output.str());
}
if (verbose == false && failedWrite == false && failed == false) {
bool match = mstr == writeMstr && sstr == writeSstr;
verify(failedWriteMatch, "write", expectStr, match, mstr.getDataStr() + " " + sstr.getDataStr(), writeMstr.getDataStr() + " " + writeSstr.getDataStr());
}
}
while (fields.empty() == false) {
delete fields.back();
fields.pop_back();
}
for (std::map<std::string, DataField*>::iterator it = templates.begin(); it!=templates.end(); it++)
delete it->second;
return 0;
}