From f1830497b017e51ecf9fd361837d34c4300adf78 Mon Sep 17 00:00:00 2001 From: Wolfgang Hottgenroth Date: Thu, 10 Aug 2017 23:33:20 +0200 Subject: [PATCH] start to parse variable data blocks, tests are yet missing, coding tables and especially encoder functions not completex --- src/codetables.ts | 118 ++++++++++++++++++++++++------- src/longframe.ts | 165 +++++++++++++++++++++++++++++++++++++++++++ src/meterbus.test.ts | 1 + src/utils.test.ts | 13 ++++ src/utils.ts | 9 +++ 5 files changed, 279 insertions(+), 27 deletions(-) diff --git a/src/codetables.ts b/src/codetables.ts index 39786c1..331b7b1 100644 --- a/src/codetables.ts +++ b/src/codetables.ts @@ -1,31 +1,95 @@ -export namespace MeterbusLibCodeTables { +import {MeterbusLibUtils} from './utils' + + +export namespace MeterbusLibCodeTables { export const MEDIUM_CODE : string[] = - ['Other', - 'Oil', - 'Electrity', - 'Gas', - 'Heat (Volume measured at return temperature: outlet', - 'Steam', - 'Hot Water', - 'Water', - 'Heat Cost Allocator', - 'Compressed Air', - 'Cooling Load Meter (Volume measured at return temperature: outlet', - 'Cooling Load Meter (Volume measured at flow temperature: inlet', - 'Heat (Volume measured at flow temperature: inlet)', - 'Heat / Cooling Load Meter', - 'Bus / System', - 'Unknown Medium', - 'Reserved (10)', - 'Reserved (11)', - 'Reserved (12)', - 'Reserved (13)', - 'Reserved (14)', - 'Reserved (15)', - 'Cold Water', - 'Dual Water', - 'Pressure', - 'A/D Converter', + [ + 'Other', + 'Oil', + 'Electrity', + 'Gas', + 'Heat (Volume measured at return temperature: outlet', + 'Steam', + 'Hot Water', + 'Water', + 'Heat Cost Allocator', + 'Compressed Air', + 'Cooling Load Meter (Volume measured at return temperature: outlet', + 'Cooling Load Meter (Volume measured at flow temperature: inlet', + 'Heat (Volume measured at flow temperature: inlet)', + 'Heat / Cooling Load Meter', + 'Bus / System', + 'Unknown Medium', + 'Reserved (10)', + 'Reserved (11)', + 'Reserved (12)', + 'Reserved (13)', + 'Reserved (14)', + 'Reserved (15)', + 'Cold Water', + 'Dual Water', + 'Pressure', + 'A/D Converter', ] + export const DIF_FUNCTION_FIELD : string[] = + [ + 'Instantaneous value', + 'Maximum value', + 'Minimum value', + 'Value during error state' + ] + + export class DCFt { + name : string + length : number + encoder : (v: number[]) => any + constructor(n : string, l : number, e : (v: number[]) => any) { + this.name = n + this.length = l + this.encoder = e + } + } + + export const DIF_CODING_FIELD : DCFt[] = + [ + new DCFt('No Data', 0, (x)=>{ return x}), + new DCFt('8 Bit Integer', 1, (x)=>{ return x[0]}), + new DCFt('16 Bit Integer', 2, (x)=>{ return (x[1] << 8) + x[0]}), + new DCFt('24 Bit Integer', 3, (x)=>{ return (x[2] << 16) + (x[1] << 8) + x[0]}), + new DCFt('32 Bit Integer', 4, (x)=>{ return (x[3] << 24) + (x[2] << 16) + (x[1] << 8) + x[0]}), + new DCFt('32 Bit Real', 4, (x)=>{ return x}), // FIXME + new DCFt('48 Bit Integer', 6, (x)=>{ return (x[5] << 40) + (x[4] << 32) + (x[3] << 24) + (x[2] << 16) + (x[1] << 8) + x[0]}), + new DCFt('64 Bit Integer', 8, (x)=>{ return (x[7] << 56) + (x[6] << 48) + (x[5] << 40) + (x[4] << 32) + (x[3] << 24) + (x[2] << 16) + (x[1] << 8) + x[0]}), + new DCFt('Selection for Readout', 0, (x)=>{ return x}), + new DCFt('2 Digit BCD', 1, (x)=>{ return MeterbusLibUtils.bcd(x)}), + new DCFt('4 Digit BCD', 2, (x)=>{ return MeterbusLibUtils.bcd(x)}), + new DCFt('6 Digit BCD', 3, (x)=>{ return MeterbusLibUtils.bcd(x)}), + new DCFt('8 Digit BCD', 4, (x)=>{ return MeterbusLibUtils.bcd(x)}), + new DCFt('variable length', -1, (x)=>{ return x}), + new DCFt('12 Digit BCD', 6, (x)=>{ return MeterbusLibUtils.bcd(x)}), + new DCFt('Special Function', 0, (x)=>{ return x}) + ] + +/* + DATA_FIELD_CODES = ( + ('No Data', 0, None), + ('8 Bit Integer', 1, lambda x: x[0]), + ('16 Bit Integer', 2, lambda x: (x[1] << 8) + x[0]), + ('24 Bit Integer', 3, lambda x: (x[2] << 16) + (x[1] << 8) + x[0]), + ('32 Bit Integer', 4, lambda x: (x[3] << 24) + (x[2] << 16) + (x[1] << 8) + x[0]), + ('32 Bit Real', 4, lambda x: struct.unpack('f', str(bytearray(x)))[0]), + ('48 Bit Integer', 6, lambda x: (x[5] << 40) + (x[4] << 32) + (x[3] << 24) + (x[2] << 16) + (x[1] << 8) + x[0]), + ('64 Bit Integer', 8, lambda x: (x[7] << 56) + (x[6] << 48) + (x[5] << 40) + (x[4] << 32) + (x[3] << 24) + (x[2] << 16) + (x[1] << 8) + x[0]), + ('Selection for Readout', 0, None), + ('2 Digit BCD', 1, lambda x: MeterbusTypeConversion.bcd(x)), + ('4 Digit BCD', 2, lambda x: MeterbusTypeConversion.bcd(x)), + ('6 Digit BCD', 3, lambda x: MeterbusTypeConversion.bcd(x)), + ('8 Digit BCD', 4, lambda x: MeterbusTypeConversion.bcd(x)), + ('variable length', -1, None), + ('12 Digit BCD', 6, lambda x: MeterbusTypeConversion.bcd(x)), + ('Special Function', 0, None), + ) +*/ + } \ No newline at end of file diff --git a/src/longframe.ts b/src/longframe.ts index bb33a7e..89acf8e 100644 --- a/src/longframe.ts +++ b/src/longframe.ts @@ -6,6 +6,8 @@ import {MeterbusLibCodeTables} from './codetables' export namespace MeterbusLibLongFrame { export class LongFrame extends MeterbusLibFrames.ControlFrame { private _fixedDataHeader : FixedDataHeader + private _variableDataBlocks : DataBlock[] = [] + get fixedDataHeader() : FixedDataHeader { return this._fixedDataHeader } constructor(telegram : number[]) { @@ -16,6 +18,16 @@ export namespace MeterbusLibLongFrame { super.parse2() // control frame parse2 method this._fixedDataHeader = new FixedDataHeader(this._telegram.slice(7, 19)) this._fixedDataHeader.parse() + + let consumed : number = 0 + while (true) { + let die : DataBlock = + new DataBlock(this._telegram.slice(19 + consumed)) + die.parse() + this._variableDataBlocks.push(die) + consumed += die.consumed + break //FIXME + } } } @@ -61,4 +73,157 @@ export namespace MeterbusLibLongFrame { } } + export abstract class ADataBlock { + protected __consumed : number = 0 + + get consumed() : number { + return this.__consumed + } + + abstract parse() : void + + toJSON() : any { + console.log("x") + return MeterbusLibUtils.jsonPrepaper(this, []) + } + + getJSON() : string { + return JSON.stringify(this) + } + } + + export class DataBlock extends ADataBlock { + private _content : VariableDataBlock | ManufacturerSpecificData + + constructor(data : number[]) { + super() + if ((data[0] & 0x0f) == 0x0f) { + this._content = new ManufacturerSpecificData(data) + } else { + this._content = new VariableDataBlock(data) + } + } + + + parse() : void { + this._content.parse() + } + + toJSON() : any { + return MeterbusLibUtils.jsonPrepaper(this._content, []) + } + } + + export class DIF { + raw : number + function : number + coding : number + lsb : number + extension : number + + toJSON() : any { + let dup = MeterbusLibUtils.clone(this) + dup.function = MeterbusLibCodeTables.DIF_FUNCTION_FIELD[dup.function] + dup.coding = MeterbusLibCodeTables.DIF_CODING_FIELD[dup.coding].name + return dup + } + } + + export class DIFE { + raw : number + extension : number + } + + export class VIF { + raw : number + unitAndMultiplier : number + extension : number + } + + export class VIFE { + raw : number + extension : number + } + + export class VariableDataBlock extends ADataBlock { + private _type : string = "VDB" + private __indata : number[] + private _dif : DIF + private _dife : DIFE[] = [] + private _vif : VIF + private _vife : VIFE[] = [] + private _data : number[] + private _value : any + + constructor(data : number[]) { + super() + this.__indata = data + } + + parse() : void { + this._dif = new DIF() + this._dif.raw = this.__indata[0] + this.__consumed++ + this._dif.function = (this._dif.raw & 0x30) >> 4 + this._dif.coding = this._dif.raw & 0x0f + this._dif.lsb = (this._dif.raw & 0x40) >> 6 + this._dif.extension = (this._dif.raw & 0x80) >> 7 + + if (this._dif.extension == 1) { + while (true) { + let dife = new DIFE() + dife.raw = this.__indata[this.__consumed] + this.__consumed++ + dife.extension = (dife.raw & 0x80) >> 7 + this._dife.push(dife) + if (dife.extension == 0) { + break + } + } + } + + this._vif = new VIF() + this._vif.raw = this.__indata[this.__consumed] + this.__consumed++ + this._vif.unitAndMultiplier = this._vif.raw & 0x7f + this._vif.extension = (this._vif.raw & 0x80) >> 7 + + if (this._vif.extension == 1) { + while (true) { + let vife = new VIFE() + vife.raw = this.__indata[this.__consumed] + this.__consumed++ + vife.extension = (vife.raw & 0x80) >> 7 + this._vife.push(vife) + if (vife.extension == 0) { + break + } + } + } + + let dcf : MeterbusLibCodeTables.DCFt = MeterbusLibCodeTables.DIF_CODING_FIELD[this._dif.coding] + this._data = this.__indata.slice(this.__consumed, + this.__consumed + dcf.length) + this.__consumed += dcf.length + + console.log(dcf.encoder) + this._value = dcf.encoder(this._data) + console.log(this._value) + } + } + + export class ManufacturerSpecificData extends ADataBlock { + private _type : string = "MSD" + private _data : number[] + + constructor(data : number[]) { + super() + this._data = data + } + + parse() : void { + + } + } + } \ No newline at end of file diff --git a/src/meterbus.test.ts b/src/meterbus.test.ts index 1153c5d..b578df2 100644 --- a/src/meterbus.test.ts +++ b/src/meterbus.test.ts @@ -180,6 +180,7 @@ describe('The Meterbus Longframe Library', () => { .to.deep.equal([0,0]) }) it('should prepare itself as JSON', () => { + console.log((telegram.frame as MeterbusLibLongFrame.LongFrame).getJSON()) expect((telegram.frame as MeterbusLibLongFrame.LongFrame).getJSON()).to.equal(json_1phase_electric) }) }) diff --git a/src/utils.test.ts b/src/utils.test.ts index ec90883..b58c99d 100644 --- a/src/utils.test.ts +++ b/src/utils.test.ts @@ -48,4 +48,17 @@ describe('The jsonPrepare function in the Meterbus Library Utils', () => { let objOut = {'a': 1, 'b':2} expect(MeterbusLibUtils.jsonPrepaper(objIn, [])).to.deep.equal(objOut) }) +}) + +describe('The clone function in the Meterbus Library Utils', () => { + it('should clone the attributes of an object', () => { + let objIn = {'a': 1, 'b': 2} + let objOut = {'a': 1, 'b': 2} + expect(MeterbusLibUtils.clone(objIn)).to.deep.equal(objOut) + }) + it('should not just return the same object', () => { + let objIn = {'a': 1, 'b':2} + let objOut = objIn + expect(MeterbusLibUtils.clone(objIn)).to.not.equal(objOut) + }) }) \ No newline at end of file diff --git a/src/utils.ts b/src/utils.ts index 3f42a9a..04afde2 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -24,5 +24,14 @@ export namespace MeterbusLibUtils { } return dup } + + export function clone(obj:any) : any { + let dup = {} + for (let key in obj) { + dup[key] = obj[key] + } + return dup + } + }