mirror
/
wmbusmeters
kopia lustrzana https://github.com/weetmuts/wmbusmeters
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
wmbusmeters/wmbus.cc

611 wiersze
21 KiB
C++
Czysty Wina Historia

// Copyright (c) 2017 Fredrik Öhrström
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include"wmbus.h"
#include<stdarg.h>
#include<unistd.h>
const char *LinkModeNames[] = {
#define X(name) #name ,
LIST_OF_LINK_MODES
#undef X
};
struct Manufacturer {
char code[4];
int m_field;
char name[64];
};
Manufacturer manufacturers[] = {
#define X(key,code,name) {#key,code,#name},
LIST_OF_MANUFACTURERS
#undef X
{"",0,""}
};
struct Initializer { Initializer(); };
static Initializer initializser_;
Initializer::Initializer() {
for (auto &m : manufacturers) {
m.m_field = \
(m.code[0]-64)*1024 +
(m.code[1]-64)*32 +
(m.code[2]-64);
}
}
void Telegram::print() {
printf("Received telegram from: %02x%02x%02x%02x\n",
a_field_address[0], a_field_address[1], a_field_address[2], a_field_address[3]);
printf(" manufacturer: (%s) %s\n",
manufacturerFlag(m_field).c_str(),
manufacturer(m_field).c_str());
printf(" device type: %s\n",
deviceType(m_field, a_field_device_type).c_str());
}
void Telegram::verboseFields() {
string man = manufacturerFlag(m_field);
verbose(" %02x%02x%02x%02x C-field=%02x M-field=%04x (%s) A-field-version=%02x A-field-dev-type=%02x (%s) Ci-field=%02x (%s)",
a_field_address[0], a_field_address[1], a_field_address[2], a_field_address[3],
c_field,
m_field,
man.c_str(),
a_field_version,
a_field_device_type,
deviceType(m_field, a_field_device_type).c_str(),
ci_field,
ciType(ci_field).c_str());
if (ci_field == 0x78) {
// No data error and no encryption possible.
}
if (ci_field == 0x7a) {
// Short data header
verbose(" CC-field=%02x (%s) ACC=%02x ",
cc_field, ccType(cc_field).c_str(),
acc,
sn[3],sn[2],sn[1],sn[0]);
}
if (ci_field == 0x8d) {
verbose(" CC-field=%02x (%s) ACC=%02x SN=%02x%02x%02x%02x",
cc_field, ccType(cc_field).c_str(),
acc,
sn[3],sn[2],sn[1],sn[0]);
}
if (ci_field == 0x8c) {
verbose(" CC-field=%02x (%s) ACC=%02x",
cc_field, ccType(cc_field).c_str(),
acc);
}
verbose("\n");
}
string manufacturer(int m_field) {
for (auto &m : manufacturers) {
if (m.m_field == m_field) return m.name;
}
return "Unknown";
}
string manufacturerFlag(int m_field) {
char a = (m_field/1024)%32+64;
char b = (m_field/32)%32+64;
char c = (m_field)%32+64;
string flag;
flag += a;
flag += b;
flag += c;
return flag;
}
string deviceType(int m_field, int a_field_device_type) {
switch (a_field_device_type) {
case 0: return "Other";
case 1: return "Oil meter";
case 2: return "Electricity meter";
case 3: return "Gas meter";
case 4: return "Heat meter";
case 5: return "Steam meter";
case 6: return "Warm Water (30°C-90°C) meter";
case 7: return "Water meter";
case 8: return "Heat Cost Allocator";
case 9: return "Compressed air meter";
case 0x0a: return "Cooling load volume at outlet meter";
case 0x0b: return "Cooling load volume at inlet meter";
case 0x0c: return "Heat volume at inlet meter";
case 0x0d: return "Heat/Cooling load meter";
case 0x0e: return "Bus/System component";
case 0x0f: return "Unknown";
case 0x15: return "Hot water (>=90°C) meter";
case 0x16: return "Cold water meter";
case 0x17: return "Hot/Cold water meter";
case 0x18: return "Pressure meter";
case 0x19: return "A/D converter";
}
return "Unknown";
}
string mediaType(int m_field, int a_field_device_type) {
switch (a_field_device_type) {
case 0: return "other";
case 1: return "oil";
case 2: return "electricity";
case 3: return "gas";
case 4: return "heat";
case 5: return "steam";
case 6: return "warm water";
case 7: return "water";
case 8: return "heat cost";
case 9: return "compressed air";
case 0x0a: return "cooling load volume at outlet";
case 0x0b: return "cooling load volume at inlet";
case 0x0c: return "heat volume at inlet";
case 0x0d: return "heat/cooling load";
case 0x0e: return "bus/system component";
case 0x0f: return "unknown";
case 0x15: return "hot water";
case 0x16: return "cold water";
case 0x17: return "hot/cold water";
case 0x18: return "pressure";
case 0x19: return "a/d converter";
}
return "Unknown";
}
bool detectIM871A(string device, SerialCommunicationManager *handler);
bool detectAMB8465(string device, SerialCommunicationManager *handler);
pair<MBusDeviceType,string> detectMBusDevice(string device, SerialCommunicationManager *handler)
{
// If auto, then assume that uev has been configured with
// with the file: `/etc/udev/rules.d/99-usb-serial.rules` containing
// SUBSYSTEM=="tty", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="ea60", SYMLINK+="im871a",MODE="0660", GROUP="yourowngroup"
// SUBSYSTEM=="tty", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", SYMLINK+="amb8465",MODE="0660", GROUP="yourowngroup"
if (device == "auto")
{
if (detectIM871A("/dev/im871a", handler))
{
return { DEVICE_IM871A, "/dev/im871a" };
}
if (detectAMB8465("/dev/amb8465", handler))
{
return { DEVICE_AMB8465, "/dev/amb8465" };
}
return { DEVICE_UNKNOWN, "" };
}
if (checkIfSimulationFile(device.c_str()))
{
return { DEVICE_SIMULATOR, device };
}
// If not auto, then test the device, is it a character device?
checkCharacterDeviceExists(device.c_str(), true);
// If im87a is tested first, a delay of 1s must be inserted
// before amb8465 is tested, lest it will not respond properly.
// It really should not matter, but perhaps is the uart of the amber
// confused by the 57600 speed....or maybe there is some other reason.
// Anyway by testing for the amb8465 first, we can immediately continue
// with the test for the im871a, without the need for a 1s delay.
// Talk amb8465 with it...
// assumes this device is configured for 9600 bps, which seems to be the default.
if (detectAMB8465(device, handler))
{
return { DEVICE_AMB8465, device };
}
// Talk im871a with it...
// assumes this device is configured for 57600 bps, which seems to be the default.
if (detectIM871A(device, handler))
{
return { DEVICE_IM871A, device };
}
return { DEVICE_UNKNOWN, "" };
}
string ciType(int ci_field)
{
if (ci_field >= 0xA0 && ci_field <= 0xB7) {
return "Mfct specific";
}
switch (ci_field) {
case 0x60: return "COSEM Data sent by the Readout device to the meter with long Transport Layer";
case 0x61: return "COSEM Data sent by the Readout device to the meter with short Transport Layer";
case 0x64: return "Reserved for OBIS-based Data sent by the Readout device to the meter with long Transport Layer";
case 0x65: return "Reserved for OBIS-based Data sent by the Readout device to the meter with short Transport Layer";
case 0x69: return "EN 13757-3 Application Layer with Format frame and no Transport Layer";
case 0x6A: return "EN 13757-3 Application Layer with Format frame and with short Transport Layer";
case 0x6B: return "EN 13757-3 Application Layer with Format frame and with long Transport Layer";
case 0x6C: return "Clock synchronisation (absolute)";
case 0x6D: return "Clock synchronisation (relative)";
case 0x6E: return "Application error from device with short Transport Layer";
case 0x6F: return "Application error from device with long Transport Layer";
case 0x70: return "Application error from device without Transport Layer";
case 0x71: return "Reserved for Alarm Report";
case 0x72: return "EN 13757-3 Application Layer with long Transport Layer";
case 0x73: return "EN 13757-3 Application Layer with Compact frame and long Transport Layer";
case 0x74: return "Alarm from device with short Transport Layer";
case 0x75: return "Alarm from device with long Transport Layer";
case 0x78: return "EN 13757-3 Application Layer without Transport Layer (to be defined)";
case 0x79: return "EN 13757-3 Application Layer with Compact frame and no header";
case 0x7A: return "EN 13757-3 Application Layer with short Transport Layer";
case 0x7B: return "EN 13757-3 Application Layer with Compact frame and short header";
case 0x7C: return "COSEM Application Layer with long Transport Layer";
case 0x7D: return "COSEM Application Layer with short Transport Layer";
case 0x7E: return "Reserved for OBIS-based Application Layer with long Transport Layer";
case 0x7F: return "Reserved for OBIS-based Application Layer with short Transport Layer";
case 0x80: return "EN 13757-3 Transport Layer (long) from other device to the meter";
case 0x81: return "Network Layer data";
case 0x82: return "For future use";
case 0x83: return "Network Management application";
case 0x8A: return "EN 13757-3 Transport Layer (short) from the meter to the other device";
case 0x8B: return "EN 13757-3 Transport Layer (long) from the meter to the other device";
case 0x8C: return "Extended Link Layer I (2 Byte)";
case 0x8D: return "Extended Link Layer II (8 Byte)";
}
return "?";
}
void Telegram::addExplanation(vector<uchar> &payload, int len, const char* fmt, ...)
{
char buf[1024];
buf[1023] = 0;
va_list args;
va_start(args, fmt);
vsnprintf(buf, 1023, fmt, args);
va_end(args);
explanations.push_back({parsed.size(), buf});
parsed.insert(parsed.end(), payload.begin()+parsed.size(), payload.begin()+parsed.size()+len);
}
void Telegram::parse(vector<uchar> &frame)
{
parsed.clear();
len = frame[0];
addExplanation(frame, 1, "%02x length (%d bytes)", len, len);
c_field = frame[1];
addExplanation(frame, 1, "%02x c-field (%s)", c_field, cType(c_field).c_str());
m_field = frame[3]<<8 | frame[2];
string man = manufacturerFlag(m_field);
addExplanation(frame, 2, "%02x%02x m-field (%02x=%s)", frame[2], frame[3], m_field, man.c_str());
a_field.resize(6);
a_field_address.resize(4);
for (int i=0; i<6; ++i) {
a_field[i] = frame[4+i];
if (i<4) { a_field_address[i] = frame[4+3-i]; }
}
addExplanation(frame, 4, "%02x%02x%02x%02x a-field-addr (%02x%02x%02x%02x)", frame[4], frame[5], frame[6], frame[7],
frame[7], frame[6], frame[5], frame[4]);
a_field_version = frame[4+4];
a_field_device_type = frame[4+5];
addExplanation(frame, 1, "%02x a-field-version", frame[8]);
addExplanation(frame, 1, "%02x a-field-type (%s)", frame[9], deviceType(m_field, a_field_device_type).c_str());
ci_field=frame[10];
addExplanation(frame, 1, "%02x ci-field (%s)", ci_field, ciType(ci_field).c_str());
int header_size = 0;
if (ci_field == 0x78) {
header_size = 0; // And no encryption possible.
} else
if (ci_field == 0x7a) {
acc = frame[11];
addExplanation(frame, 1, "%02x acc", acc);
status = frame[12];
addExplanation(frame, 1, "%02x status ()", status);
configuration = frame[13]<<8 | frame[14];
addExplanation(frame, 2, "%02x%02x configuration ()", frame[13], frame[14]);
header_size = 4;
} else
if (ci_field == 0x8d || ci_field == 0x8c) {
cc_field = frame[11];
addExplanation(frame, 1, "%02x cc-field (%s)", cc_field, ccType(cc_field).c_str());
acc = frame[12];
addExplanation(frame, 1, "%02x acc", acc);
header_size = 2;
if (ci_field == 0x8d) {
sn[0] = frame[13];
sn[1] = frame[14];
sn[2] = frame[15];
sn[3] = frame[16];
addExplanation(frame, 4, "%02x%02x%02x%02x sn", sn[0], sn[1], sn[2], sn[3]);
header_size = 6;
}
} else {
warning("Unknown ci-field %02x\n", ci_field);
}
payload.clear();
payload.insert(payload.end(), frame.begin()+(11+header_size), frame.end());
verbose("(wmbus) received telegram");
verboseFields();
debugPayload("(wmbus) frame", frame);
debugPayload("(wmbus) payload", payload);
if (isDebugEnabled()) {
explainParse("(wmbus)", 0);
}
}
void Telegram::explainParse(string intro, int from)
{
for (auto& p : explanations) {
if (p.first < from) continue;
printf("%s ", intro.c_str());
for (int i=0; i<p.first; ++i) {
printf(" ");
}
printf("%s\n", p.second.c_str());
}
string hex = bin2hex(parsed);
printf("%s %s\n", intro.c_str(), hex.c_str());
}
string cType(int c_field)
{
switch (c_field) {
case 0x44: return "SND_NR";
case 0x46: return "SND_IR";
case 0x48: return "RSP_UD";
}
return "?";
}
string ccType(int cc_field)
{
string s = "";
if (cc_field & CC_B_BIDIRECTIONAL_BIT) s += "bidir ";
if (cc_field & CC_RD_RESPONSE_DELAY_BIT) s += "fast_resp ";
else s += "slow_resp ";
if (cc_field & CC_S_SYNCH_FRAME_BIT) s += "sync ";
if (cc_field & CC_R_RELAYED_BIT) s+= "relayed "; // Relayed by a repeater
if (cc_field & CC_P_HIGH_PRIO_BIT) s+= "prio ";
if (s.back() == ' ') s.pop_back();
return s;
}
string difType(int dif)
{
string s;
int t = dif & 0x0f;
switch (t) {
case 0x0: s+= "No data"; break;
case 0x1: s+= "8 Bit Integer/Binary"; break;
case 0x2: s+= "16 Bit Integer/Binary"; break;
case 0x3: s+= "24 Bit Integer/Binary"; break;
case 0x4: s+= "32 Bit Integer/Binary"; break;
case 0x5: s+= "32 Bit Real"; break;
case 0x6: s+= "48 Bit Integer/Binary"; break;
case 0x7: s+= "64 Bit Integer/Binary"; break;
case 0x8: s+= "Selection for Readout"; break;
case 0x9: s+= "2 digit BCD"; break;
case 0xA: s+= "4 digit BCD"; break;
case 0xB: s+= "6 digit BCD"; break;
case 0xC: s+= "8 digit BCD"; break;
case 0xD: s+= "variable length"; break;
case 0xE: s+= "12 digit BCD"; break;
case 0xF: s+= "Special Functions"; break;
default: s+= "?"; break;
}
t = dif & 0x30;
switch (t) {
case 0x00: s += " Instantaneous value"; break;
case 0x10: s += "Maximum value"; break;
case 0x20: s += "Minimum value"; break;
case 0x30: s+= "Value during error state"; break;
default: s += "?"; break;
}
return s;
}
string vifType(int vif)
{
int extension = vif & 0x80;
int t = vif & 0x7f;
if (extension) {
switch(vif) {
case 0xfb: return "First extension of VIF-codes";
case 0xfd: return "Second extension of VIF-codes";
case 0xef: return "Reserved extension";
}
}
switch (t) {
case 0x00: return "Energy mWh";
case 0x01: return "Energy 10⁻² Wh";
case 0x02: return "Energy 10⁻¹ Wh";
case 0x03: return "Energy Wh";
case 0x04: return "Energy 10¹ Wh";
case 0x05: return "Energy 10² Wh";
case 0x06: return "Energy kWh";
case 0x07: return "Energy 10⁴ Wh";
case 0x08: return "Energy J";
case 0x09: return "Energy 10¹ J";
case 0x0A: return "Energy 10² J";
case 0x0B: return "Energy kJ";
case 0x0C: return "Energy 10⁴ J";
case 0x0D: return "Energy 10⁵ J";
case 0x0E: return "Energy MJ";
case 0x0F: return "Energy 10⁷ J";
case 0x10: return "Volume cm³";
case 0x11: return "Volume 10⁻⁵ m³";
case 0x12: return "Volume 10⁻⁴ m³";
case 0x13: return "Volume l";
case 0x14: return "Volume 10⁻² m³";
case 0x15: return "Volume 10⁻¹ m³";
case 0x16: return "Volume m³";
case 0x17: return "Volume 10¹ m³";
case 0x18: return "Mass g";
case 0x19: return "Mass 10⁻² kg";
case 0x1A: return "Mass 10⁻¹ kg";
case 0x1B: return "Mass kg";
case 0x1C: return "Mass 10¹ kg";
case 0x1D: return "Mass 10² kg";
case 0x1E: return "Mass t";
case 0x1F: return "Mass 10⁴ kg";
case 0x20: return "On time seconds";
case 0x21: return "On time minutes";
case 0x22: return "On time hours";
case 0x23: return "On time days";
case 0x24: return "Operating time seconds";
case 0x25: return "Operating time minutes";
case 0x26: return "Operating time hours";
case 0x27: return "Operating time days";
case 0x28: return "Power mW";
case 0x29: return "Power 10⁻² W";
case 0x2A: return "Power 10⁻¹ W";
case 0x2B: return "Power W";
case 0x2C: return "Power 10¹ W";
case 0x2D: return "Power 10² W";
case 0x2E: return "Power kW";
case 0x2F: return "Power 10⁴ W";
case 0x30: return "Power J/h";
case 0x31: return "Power 10¹ J/h";
case 0x32: return "Power 10² J/h";
case 0x33: return "Power kJ/h";
case 0x34: return "Power 10⁴ J/h";
case 0x35: return "Power 10⁵ J/h";
case 0x36: return "Power MJ/h";
case 0x37: return "Power 10⁷ J/h";
case 0x38: return "Volume flow cm³/h";
case 0x39: return "Volume flow 10⁻⁵ m³/h";
case 0x3A: return "Volume flow 10⁻⁴ m³/h";
case 0x3B: return "Volume flow l/h";
case 0x3C: return "Volume flow 10⁻² m³/h";
case 0x3D: return "Volume flow 10⁻¹ m³/h";
case 0x3E: return "Volume flow m³/h";
case 0x3F: return "Volume flow 10¹ m³/h";
case 0x40: return "Volume flow ext. 10⁻⁷ m³/min";
case 0x41: return "Volume flow ext. cm³/min";
case 0x42: return "Volume flow ext. 10⁻⁵ m³/min";
case 0x43: return "Volume flow ext. 10⁻⁴ m³/min";
case 0x44: return "Volume flow ext. l/min";
case 0x45: return "Volume flow ext. 10⁻² m³/min";
case 0x46: return "Volume flow ext. 10⁻¹ m³/min";
case 0x47: return "Volume flow ext. m³/min";
case 0x48: return "Volume flow ext. mm³/s";
case 0x49: return "Volume flow ext. 10⁻⁸ m³/s";
case 0x4A: return "Volume flow ext. 10⁻⁷ m³/s";
case 0x4B: return "Volume flow ext. cm³/s";
case 0x4C: return "Volume flow ext. 10⁻⁵ m³/s";
case 0x4D: return "Volume flow ext. 10⁻⁴ m³/s";
case 0x4E: return "Volume flow ext. l/s";
case 0x4F: return "Volume flow ext. 10⁻² m³/s";
case 0x50: return "Mass g/h";
case 0x51: return "Mass 10⁻² kg/h";
case 0x52: return "Mass 10⁻¹ kg/h";
case 0x53: return "Mass kg/h";
case 0x54: return "Mass 10¹ kg/h";
case 0x55: return "Mass 10² kg/h";
case 0x56: return "Mass t/h";
case 0x57: return "Mass 10⁴ kg/h";
case 0x58: return "Flow temperature 10⁻³ °C";
case 0x59: return "Flow temperature 10⁻² °C";
case 0x5A: return "Flow temperature 10⁻¹ °C";
case 0x5B: return "Flow temperature °C";
case 0x5C: return "Return temperature 10⁻³ °C";
case 0x5D: return "Return temperature 10⁻² °C";
case 0x5E: return "Return temperature 10⁻¹ °C";
case 0x5F: return "Return temperature °C";
case 0x60: return "Temperature difference mK";
case 0x61: return "Temperature difference 10⁻² K";
case 0x62: return "Temperature difference 10⁻¹ K";
case 0x63: return "Temperature difference K";
case 0x64: return "External temperature 10⁻³ °C";
case 0x65: return "External temperature 10⁻² °C";
case 0x66: return "External temperature 10⁻¹ °C";
case 0x67: return "External temperature °C";
case 0x68: return "Pressure mbar";
case 0x69: return "Pressure 10⁻² bar";
case 0x6A: return "Pressure 10⁻1 bar";
case 0x6B: return "Pressure bar";
case 0x6C: return "Date type G";
case 0x6E: return "Units for H.C.A.";
case 0x6F: return "Reserved";
case 0x70: return "Averaging duration seconds";
case 0x71: return "Averaging duration minutes";
case 0x72: return "Averaging duration hours";
case 0x73: return "Averaging duration days";
case 0x74: return "Actuality duration seconds";
case 0x75: return "Actuality duration minutes";
case 0x76: return "Actuality duration hours";
case 0x77: return "Actuality duration days";
case 0x78: return "Fabrication no";
case 0x79: return "Enhanced identification";
case 0x80: return "Address";
case 0x7C: return "VIF in following string (length in first byte)";
case 0x7E: return "Any VIF";
case 0x7F: return "Manufacturer specific";
default: return "?";
}
}
string vifeType(int vif, int vife)
{
//int extension = vif & 0x80;
//int t = vif & 0x7f;
if (vif == 0x83 && vife == 0x3b) {
return "Forward flow contribution only";
}
if (vif == 0xff) {
return "?";
}
return "?";
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik