808 lines
28 KiB
C++
808 lines
28 KiB
C++
/*
|
|
* Copyright (C) John Baier 2014 <ebusd@johnm.de>
|
|
*
|
|
* This file is part of ebusd.
|
|
*
|
|
* ebusd is free 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, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* ebusd 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with ebusd. If not, see http://www.gnu.org/licenses/.
|
|
*/
|
|
|
|
#include "data.h"
|
|
#include "decode.h"
|
|
#include "encode.h"
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#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*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. */
|
|
static const char* dayNames[] = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
|
|
|
|
#define FIELD_SEPARATOR ';'
|
|
#define VALUE_SEPARATOR ','
|
|
#define NULL_VALUE "-"
|
|
|
|
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 = 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;[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)
|
|
return RESULT_ERR_EOF;
|
|
|
|
if (dstAddress == BROADCAST || isMaster(dstAddress)
|
|
|| (isTemplate == false && isSetMessage == true && posStr[0] != 0 && posStr[0] <= '9')
|
|
|| posStr[0] == 'm') { // master data
|
|
partType = pt_masterData;
|
|
if (posStr[0] == 'm')
|
|
posStr++;
|
|
}
|
|
else if ((isTemplate == false && isSetMessage == false && posStr[0] != 0 && posStr[0] <= '9')
|
|
|| posStr[0] == 's') { // slave data
|
|
partType = pt_slaveData;
|
|
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) {
|
|
length = 0;
|
|
}
|
|
else {
|
|
offset = 0;
|
|
length = 0;
|
|
std::istringstream stream(posStr);
|
|
while (std::getline(stream, token, '-') != 0) {
|
|
if (++offsetCnt > 2)
|
|
return RESULT_ERR_INVALID_ARG; //invalid pos definition
|
|
|
|
const char* start = token.c_str();
|
|
char* end = NULL;
|
|
unsigned int pos = strtoul(start, &end, 10) - 1; // 1-based
|
|
if (end != start + strlen(start))
|
|
return RESULT_ERR_INVALID_ARG; // invalid pos definition
|
|
|
|
if (pos > maxPos) // TODO check this in real offset as well
|
|
return RESULT_ERR_INVALID_ARG; // invalid pos definition
|
|
|
|
if (offsetCnt == 1)
|
|
offset = pos;
|
|
else if (pos >= offset)
|
|
length = pos + 1 - offset;
|
|
else { // wrong order e.g. 4-3
|
|
length = offset - (pos + 1);
|
|
offset = pos;
|
|
}
|
|
}
|
|
}
|
|
|
|
const char* typeStr = (*it++).c_str();
|
|
if (typeStr[0] == 0)
|
|
return RESULT_ERR_EOF;
|
|
|
|
std::map<unsigned int, std::string> values;
|
|
if (it != end) {
|
|
std::string divisorStr = *it++;
|
|
if (divisorStr.empty() == false) {
|
|
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 {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (it == end)
|
|
unit = "";
|
|
else {
|
|
unit = *it++;
|
|
|
|
if (unit.length() == 1 && unit[0] == '-')
|
|
unit.clear();
|
|
}
|
|
|
|
if (it == end)
|
|
comment = "";
|
|
else {
|
|
comment = *it++;
|
|
if (comment.length() == 1 && comment[0] == '-')
|
|
comment.clear();
|
|
}
|
|
|
|
// 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;
|
|
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 (useLength == 0)
|
|
useLength = 1; // minimum length defaults to 1
|
|
else if (useLength > numBytes)
|
|
return RESULT_ERR_INVALID_ARG; // invalid length
|
|
}
|
|
else if (useLength == 0)
|
|
useLength = numBytes;
|
|
else if (useLength != numBytes)
|
|
continue; // check for another one with same name but different length
|
|
|
|
switch (dataType.type)
|
|
{
|
|
case bt_str:
|
|
case bt_hexstr:
|
|
case bt_dat:
|
|
case bt_tim:
|
|
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) {
|
|
for (unsigned int i = 0; i < sizeof(dayNames) / sizeof(dayNames[0]); i++)
|
|
values[dataType.minValueOrLength + i] = dayNames[i];
|
|
}
|
|
if (values.empty() == true || (dataType.flags & LST) == 0) {
|
|
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
|
|
|| values.rbegin()->first > dataType.maxValueOrLength)
|
|
return RESULT_ERR_INVALID_ARG;
|
|
fields.push_back(new ValueListDataField(name, partType, offset, useLength, dataType, unit, comment, values));
|
|
return RESULT_OK;
|
|
}
|
|
}
|
|
}
|
|
return RESULT_ERR_INVALID_ARG;
|
|
}
|
|
|
|
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, baseOffset, output);
|
|
if (result != RESULT_OK)
|
|
return result;
|
|
|
|
if (verbose && m_unit.length() > 0)
|
|
output << " " << m_unit;
|
|
if (verbose && m_comment.length() > 0)
|
|
output << " [" << m_comment << "]";
|
|
|
|
return RESULT_OK;
|
|
}
|
|
|
|
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;
|
|
}
|
|
return writeSymbols(input, baseOffset, 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 (baseOffset + end > input.size())
|
|
return RESULT_ERR_INVALID_ARG;
|
|
|
|
if ((m_dataType.flags & REV) != 0) { // reverted binary representation (most significant byte first)
|
|
end = start - 1;
|
|
start = m_offset + m_length - 1;
|
|
incr = -1;
|
|
}
|
|
|
|
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[baseOffset + offset];
|
|
if ((m_dataType.flags & BCD) != 0) {
|
|
if ((ch & 0xf0) > 0x90 || (ch & 0x0f) > 0x09)
|
|
return RESULT_ERR_INVALID_ARG; // invalid BCD
|
|
ch = (ch >> 4) * 10 + (ch & 0x0f);
|
|
}
|
|
switch (m_dataType.type)
|
|
{
|
|
case bt_hexstr:
|
|
if (i > 0)
|
|
output << ' ';
|
|
output << std::nouppercase << std::setw(2) << std::hex
|
|
<< std::setfill('0') << static_cast<unsigned>(ch);
|
|
break;
|
|
case bt_dat:
|
|
if (i + 1 == m_length)
|
|
output << (2000 + ch);
|
|
else if (ch < 1 || (i == 0 && ch > 31) || (i == 1 && ch > 12))
|
|
return RESULT_ERR_INVALID_ARG; // invalid date
|
|
else
|
|
output << std::setw(2) << std::setfill('0') << static_cast<unsigned>(ch) << ".";
|
|
break;
|
|
case bt_tim:
|
|
if (m_length == 1) { // truncated time
|
|
if (i == 0) {
|
|
ch /= 6; // hours
|
|
offset -= incr; // repeat for minutes
|
|
}
|
|
else
|
|
ch = (ch % 6) * 10; // minutes
|
|
}
|
|
if ((i == 0 && ch > 23) || (i > 0 && ch > 59))
|
|
return RESULT_ERR_INVALID_ARG; // invalid time
|
|
if (i > 0)
|
|
output << ":";
|
|
output << std::setw(2) << std::setfill('0') << static_cast<unsigned>(ch);
|
|
break;
|
|
default:
|
|
if (ch < 0x20)
|
|
ch = m_dataType.replacement;
|
|
output << static_cast<char>(ch);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return RESULT_OK;
|
|
}
|
|
|
|
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;
|
|
const char* str;
|
|
char* strEnd;
|
|
unsigned long int value = 0, hours = 0;
|
|
std::string token;
|
|
|
|
if ((m_dataType.flags & REV) != 0) { // reverted binary representation (most significant byte first)
|
|
end = start - 1;
|
|
start = m_offset + m_length - 1;
|
|
incr = -1;
|
|
}
|
|
|
|
size_t i = 0;
|
|
for (size_t offset = start; offset != end; offset += incr, i++) {
|
|
switch (m_dataType.type)
|
|
{
|
|
case bt_hexstr:
|
|
while (input.peek() == ' ')
|
|
input.get();
|
|
if (input.eof() == true) // no more digits
|
|
value = m_dataType.replacement; // fill up with replacement
|
|
else {
|
|
token.clear();
|
|
token.push_back(input.get());
|
|
if (input.eof() == true)
|
|
return RESULT_ERR_INVALID_ARG;
|
|
token.push_back(input.get());
|
|
if (input.eof() == true)
|
|
return RESULT_ERR_INVALID_ARG; // invalid hex value
|
|
|
|
str = token.c_str();
|
|
strEnd = NULL;
|
|
value = strtoul(str, &strEnd, 16);
|
|
if (strEnd != str + strlen(str))
|
|
return RESULT_ERR_INVALID_ARG; // invalid hex value
|
|
}
|
|
break;
|
|
case bt_dat:
|
|
if (m_length == 4 && i == 2)
|
|
continue; // skip weekday in between
|
|
if (std::getline(input, token, '.') == 0)
|
|
return RESULT_ERR_INVALID_ARG; // incomplete
|
|
str = token.c_str();
|
|
strEnd = NULL;
|
|
value = strtoul(str, &strEnd, 10);
|
|
if (strEnd != str + strlen(str))
|
|
return RESULT_ERR_INVALID_ARG; // invalid date part
|
|
if (i + 1 == m_length && value >= 2000)
|
|
value -= 2000;
|
|
else if (value < 1 || (i == 0 && value > 31) || (i == 1 && value > 12))
|
|
return RESULT_ERR_INVALID_ARG; // invalid date part
|
|
break;
|
|
case bt_tim:
|
|
if (std::getline(input, token, ':') == 0)
|
|
return RESULT_ERR_INVALID_ARG; // incomplete
|
|
str = token.c_str();
|
|
strEnd = NULL;
|
|
value = strtoul(str, &strEnd, 10);
|
|
if (strEnd != str + strlen(str))
|
|
return RESULT_ERR_INVALID_ARG; // invalid time part
|
|
if ((i == 0 && value > 23) || (i > 0 && value > 59))
|
|
return RESULT_ERR_INVALID_ARG; // invalid time part
|
|
if (m_length == 1) { // truncated time
|
|
if (i == 0) {
|
|
offset -= incr; // repeat for minutes
|
|
hours = value;
|
|
continue;
|
|
}
|
|
if ((value % 10) != 0)
|
|
return RESULT_ERR_INVALID_ARG; // invalid truncated time minutes
|
|
value = hours * 6 + (value / 10);
|
|
if (value > 24 * 6)
|
|
return RESULT_ERR_INVALID_ARG; // invalid time
|
|
}
|
|
break;
|
|
default:
|
|
value = input.get();
|
|
if (input.eof() == true || value < 0x20)
|
|
value = m_dataType.replacement;
|
|
break;
|
|
}
|
|
if ((m_dataType.flags & BCD) != 0) {
|
|
if (value > 99)
|
|
return RESULT_ERR_INVALID_ARG; // invalid BCD
|
|
value = (value / 10) << 4 | (value % 10);
|
|
}
|
|
if (value > 0xff)
|
|
return RESULT_ERR_INVALID_ARG; // value out of range
|
|
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 char baseOffset, unsigned int& value)
|
|
{
|
|
size_t start = m_offset, end = m_offset + m_length;
|
|
int incr = 1;
|
|
unsigned char ch;
|
|
|
|
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)
|
|
end = start - 1;
|
|
start = m_offset + m_length - 1;
|
|
incr = -1;
|
|
}
|
|
|
|
value = 0;
|
|
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;
|
|
return RESULT_OK;
|
|
}
|
|
if ((ch & 0xf0) > 0x90 || (ch & 0x0f) > 0x09)
|
|
return RESULT_ERR_INVALID_ARG; // invalid BCD
|
|
|
|
ch = (ch >> 4) * 10 + (ch & 0x0f);
|
|
value += ch * exp;
|
|
exp *= 100;
|
|
}
|
|
else {
|
|
value |= ch * exp;
|
|
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,
|
|
unsigned char baseOffset, SymbolString& output)
|
|
{
|
|
size_t start = m_offset, end = m_offset + m_length;
|
|
int incr = 1;
|
|
unsigned char ch;
|
|
|
|
if ((m_dataType.flags & REV) != 0) { // reverted binary representation (most significant byte first)
|
|
end = start - 1;
|
|
start = m_offset + m_length - 1;
|
|
incr = -1;
|
|
}
|
|
|
|
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;
|
|
else {
|
|
ch = (value / exp) % 100;
|
|
ch = ((ch / 10) << 4) | (ch % 10);
|
|
}
|
|
exp = exp * 100;
|
|
}
|
|
else {
|
|
ch = (value / exp) & 0xff;
|
|
exp = exp << 8;
|
|
}
|
|
if (offset == start && (m_dataType.numBits % 8) != 0 && baseOffset + offset < output.size())
|
|
output[baseOffset + offset] |= ch;
|
|
else
|
|
output[baseOffset + offset] = ch;
|
|
}
|
|
|
|
return RESULT_OK;
|
|
}
|
|
|
|
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, baseOffset, value);
|
|
if (result != RESULT_OK)
|
|
return result;
|
|
|
|
if (value == m_dataType.replacement) {
|
|
output << NULL_VALUE;
|
|
return RESULT_OK;
|
|
}
|
|
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((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.numBits);
|
|
else
|
|
signedValue = (int) value;
|
|
|
|
if (m_divisor <= 1)
|
|
output << static_cast<int>(signedValue);
|
|
else
|
|
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,
|
|
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.numBits != 32)
|
|
value = (unsigned int) (signedValue + (1 << m_dataType.numBits));
|
|
else
|
|
value = (unsigned int) signedValue;
|
|
}
|
|
else
|
|
value = strtoul(str, &strEnd, 10);
|
|
if (strEnd != str + len)
|
|
return RESULT_ERR_INVALID_ARG; // invalid value
|
|
}
|
|
else {
|
|
char* strEnd = NULL;
|
|
double dvalue = strtod(str, &strEnd);
|
|
if (strEnd != str + len)
|
|
return RESULT_ERR_INVALID_ARG; // invalid value
|
|
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.numBits != 32)
|
|
value = (unsigned int) (dvalue + (1 << m_dataType.numBits));
|
|
else
|
|
value = (unsigned int) dvalue;
|
|
}
|
|
else {
|
|
if (dvalue < 0.0 || dvalue >= (1LL << (8 * m_length)))
|
|
return RESULT_ERR_INVALID_ARG; // value out of range
|
|
value = (unsigned int) dvalue;
|
|
}
|
|
}
|
|
|
|
if ((m_dataType.flags & SIG) != 0) { // 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
|
|
}
|
|
else if (value > m_dataType.maxValueOrLength)
|
|
return RESULT_ERR_INVALID_ARG; // value out of range
|
|
}
|
|
else if (value < m_dataType.minValueOrLength || value > m_dataType.maxValueOrLength)
|
|
return RESULT_ERR_INVALID_ARG; // value out of range
|
|
}
|
|
|
|
return writeRawValue(value, baseOffset, 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, 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;
|
|
}
|
|
|
|
return RESULT_ERR_INVALID_ARG; // value assignment not found
|
|
}
|
|
|
|
result_t ValueListDataField::writeSymbols(std::istringstream& input,
|
|
unsigned char baseOffset, SymbolString& output)
|
|
{
|
|
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, 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
|
|
}
|
|
|
|
} //namespace
|