142 lines
3.9 KiB
C++
142 lines
3.9 KiB
C++
/*
|
|
* ebusd - daemon for communication with eBUS heating systems.
|
|
* Copyright (C) 2016 John Baier <ebusd@ebusd.eu>
|
|
*
|
|
* This program 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.
|
|
*
|
|
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include "datatype.h"
|
|
#include "tem.h"
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <vector>
|
|
#include <cstring>
|
|
#include <math.h>
|
|
#include <typeinfo>
|
|
|
|
using namespace std;
|
|
|
|
void contrib_tem_register() {
|
|
DataTypeList::getInstance()->add(new TemParamDataType("TEM_P"));
|
|
}
|
|
|
|
result_t TemParamDataType::derive(int divisor, unsigned char bitCount, NumberDataType* &derived)
|
|
{
|
|
if (divisor == 0) {
|
|
divisor = 1;
|
|
}
|
|
if (bitCount == 0) {
|
|
bitCount = m_bitCount;
|
|
}
|
|
if (divisor == 1 && bitCount == 16) {
|
|
derived = this;
|
|
return RESULT_OK;
|
|
}
|
|
return RESULT_ERR_INVALID_ARG;
|
|
}
|
|
|
|
result_t TemParamDataType::readSymbols(SymbolString& input, const bool isMaster,
|
|
const unsigned char offset, const unsigned char length,
|
|
ostringstream& output, OutputFormat outputFormat)
|
|
{
|
|
unsigned int value = 0;
|
|
|
|
result_t result = readRawValue(input, offset, length, value);
|
|
if (result != RESULT_OK) {
|
|
return result;
|
|
}
|
|
|
|
if (value == m_replacement) {
|
|
if (outputFormat & OF_JSON) {
|
|
output << "null";
|
|
} else {
|
|
output << NULL_VALUE;
|
|
}
|
|
return RESULT_OK;
|
|
}
|
|
int grp = 0, num = 0;
|
|
if (isMaster) {
|
|
grp = (value & 0x1f); // grp in bits 0...5
|
|
num = ((value >> 8) & 0x7f); // num in bits 8...13
|
|
} else {
|
|
grp = ((value >> 7) & 0x1f); // grp in bits 7...11
|
|
num = (value & 0x7f); // num in bits 0...6
|
|
}
|
|
if (outputFormat & OF_JSON) {
|
|
output << '"';
|
|
}
|
|
output << setfill('0') << setw(2) << dec << static_cast<int>(grp) << '-' << setw(3) << static_cast<int>(num);
|
|
if (outputFormat & OF_JSON) {
|
|
output << '"';
|
|
}
|
|
output << setfill(' ') << setw(0); // reset
|
|
return RESULT_OK;
|
|
}
|
|
|
|
result_t TemParamDataType::writeSymbols(istringstream& input,
|
|
const unsigned char offset, const unsigned char length,
|
|
SymbolString& output, const bool isMaster, unsigned char* usedLength)
|
|
{
|
|
unsigned int value;
|
|
int grp, num;
|
|
string token;
|
|
|
|
const char* str = input.str().c_str();
|
|
if (strcasecmp(str, NULL_VALUE) == 0) {
|
|
value = m_replacement; // replacement value
|
|
} else {
|
|
if (input.eof() || !getline(input, token, '-')) {
|
|
return RESULT_ERR_EOF; // incomplete
|
|
}
|
|
str = token.c_str();
|
|
if (str == NULL || *str == 0) {
|
|
return RESULT_ERR_EOF; // input too short
|
|
}
|
|
char* strEnd = NULL;
|
|
grp = (unsigned int)strtoul(str, &strEnd, 10);
|
|
if (strEnd == NULL || strEnd == str || *strEnd != 0) {
|
|
return RESULT_ERR_INVALID_NUM; // invalid value
|
|
}
|
|
if (input.eof() || !getline(input, token, '-')) {
|
|
return RESULT_ERR_EOF; // incomplete
|
|
}
|
|
str = token.c_str();
|
|
if (str == NULL || *str == 0) {
|
|
return RESULT_ERR_EOF; // input too short
|
|
}
|
|
strEnd = NULL;
|
|
num = (unsigned int)strtoul(str, &strEnd, 10);
|
|
if (strEnd == NULL || strEnd == str || *strEnd != 0) {
|
|
return RESULT_ERR_INVALID_NUM; // invalid value
|
|
}
|
|
if (grp < 0 || grp > 0x1f || num < 0 || num > 0x7f) {
|
|
return RESULT_ERR_OUT_OF_RANGE; // value out of range
|
|
}
|
|
if (isMaster) {
|
|
value = grp | (num<<8); // grp in bits 0...5, num in bits 8...13
|
|
} else {
|
|
value = (grp<<7) | num; // grp in bits 7...11, num in bits 0...6
|
|
}
|
|
}
|
|
if (value < getMinValue() || value > getMaxValue()) {
|
|
return RESULT_ERR_OUT_OF_RANGE; // value out of range
|
|
}
|
|
return writeRawValue(value, offset, length, output, usedLength);
|
|
}
|