iobroker.e3oncan 0.6.14 → 0.6.15

package/README.md

@@ -102,6 +102,9 @@ Yes, that is possible under certain conditions:
     Placeholder for the next version (at the beginning of the line):
     ### **WORK IN PROGRESS**
 -->
+### 0.6.15 (2024-01-23)
+* (MyHomeMyData) Fix for Utf8 codec for handling of special characters, e.g. umlauts
+
 ### 0.6.14 (2024-01-22)
 * (MyHomeMyData) Replace '.' by '_' in datapoint ids to avoid unwanted sub structure in data states
 * (MyHomeMyData) Added more informations about white list for writables in Readme.

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "e3oncan",
-    "version": "0.6.14",
+    "version": "0.6.15",
     "news": {
+      "0.6.15": {
+        "en": "Fix for Utf8 codec for handling of special characters, e.g. umlauts",
+        "de": "Fix für Utf8-Codec zum Umgang mit Sonderzeichen, z.B. umlauts",
+        "ru": "Fix for Utf8 codec для обработки специальных символов, например, umlauts",
+        "pt": "Fix para Codec Utf8 para manipulação de caracteres especiais, por exemplo, umlauts",
+        "nl": "Fix voor Utf8 codec voor het hanteren van speciale tekens, bijvoorbeeld umlauts",
+        "fr": "Correction pour Codec Utf8 pour la manipulation de caractères spéciaux, p.ex. umlauts",
+        "it": "Fissaggio per Codice Utf8 per la gestione di caratteri speciali, ad esempio umlauts",
+        "es": "Corrección Utf8 codec para el manejo de caracteres especiales, por ejemplo umlauts",
+        "pl": "Napraw dla Kod Utf8 do obsługi znaków specjalnych, np. umlautów",
+        "uk": "Фіксація Utf8 кодека для обробки спеціальних символів, наприклад, umlauts",
+        "zh-cn": "修复 Utf8 处理特殊字符的编码器, 例如 umlauts"
+      },
       "0.6.14": {
         "en": "Replace '.' by '_' in datapoint ids to avoid unwanted sub structure in data states\nAdded more informations about white list for writables in Readme.\nRecognize loss of CAN connection.\nImproved handling of info.connection.",
         "de": "Ersetzen Sie '.' durch '_' in Datapoint ids, um unerwünschte Unterstruktur in Datenzuständen zu vermeiden\nWeitere Informationen zur Weißen Liste für schreibbare in Readme.\nErkennen Verlust der CAN-Verbindung.\nVerbesserte Handhabung von info.connection.",
@@ -80,19 +93,6 @@
         "pl": "Bugfix: Tylko Linux jest obsługiwany",
         "uk": "Помилки: Тільки Linux підтримується",
         "zh-cn": "错误修正 : 仅支持 Linux"
-      },
-      "0.6.8": {
-        "en": "Initial npm version",
-        "de": "Ursprüngliche npm-Version",
-        "ru": "Первоначальная версия npm",
-        "pt": "Versão inicial npm",
-        "nl": "Eerste npm-versie",
-        "fr": "Version initiale npm",
-        "it": "Versione npm iniziale",
-        "es": "Versión inicial npm",
-        "pl": "Początkowa wersja npm",
-        "uk": "Початкова версія npm",
-        "zh-cn": "初始 npm 版本"
       }
     },
     "title": "Viessmann E3 CAN do",

package/lib/canUds.js

@@ -365,17 +365,21 @@ class uds {
         switch (dcs.channel) {
             case 'json':
                 // Change in json data
-                byteArr = await this.storage.encodeDataCAN(ctx, this, did, JSON.parse(state.val));
-                if (byteArr) {
-                    await this.pushCmnd(ctx, 'write', [[did,byteArr]]);
-                    setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,this,did);    // Read value after 2500 ms
-                } else {
-                    ctx.log.error('User command UDS WriteByDid on '+this.config.stateBase+': Encoding of data failed.');
+                try {
+                    byteArr = await this.storage.encodeDataCAN(ctx, this, did, await JSON.parse(state.val));
+                    if (byteArr) {
+                        await this.pushCmnd(ctx, 'write', [[did,byteArr]]);
+                        setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,this,did);    // Read value after 2500 ms
+                    } else {
+                        ctx.log.error('User command UDS WriteByDid on '+this.config.stateBase+': Encoding of data failed.');
+                    }
+                } catch(e) {
+                    ctx.log.error('WriteByDid(): Encoding of data failed on '+this.config.stateBase+'.'+String(did)+'; err='+JSON.stringify(e));
                 }
                 break;
             case 'raw':
                 // Change in raw data
-                byteArr = this.storage.toByteArray(JSON.parse(state.val));
+                byteArr = this.storage.toByteArray(await JSON.parse(state.val));
                 if (byteArr) {
                     await this.pushCmnd(ctx, 'write', [[did,byteArr]]);
                     setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,this,did);    // Read value after 2500 ms
@@ -389,12 +393,16 @@ class uds {
                 lenBaseId = ctx.namespace.length+dcs.device.length+dcs.channel.length+dcs.state.length+3;
                 if (id.length == lenBaseId) {
                     // Scalar value w/o sub structure
-                    byteArr = await this.storage.encodeDataCAN(ctx, this, did, JSON.parse(state.val));
-                    if (byteArr) {
-                        await this.pushCmnd(ctx, 'write', [[did,byteArr]]);
-                        setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,this,did);    // Read value after 2500 ms
-                    } else {
-                        ctx.log.error('User command UDS WriteByDid on '+this.config.stateBase+': Encoding of data failed.');
+                    try {
+                        byteArr = await this.storage.encodeDataCAN(ctx, this, did, await JSON.parse(state.val));
+                        if (byteArr) {
+                            await this.pushCmnd(ctx, 'write', [[did,byteArr]]);
+                            setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,this,did);    // Read value after 2500 ms
+                        } else {
+                            ctx.log.error('User command UDS WriteByDid on '+this.config.stateBase+': Encoding of data failed.');
+                        }
+                    } catch(e) {
+                        ctx.log.error('WriteByDid(): Encoding of data failed on '+this.config.stateBase+'.'+String(did)+'; err='+JSON.stringify(e));
                     }
                     break;
                 }
@@ -402,21 +410,6 @@ class uds {
                 // Build json object for complete object tree of changed did:
                 await ctx.getStatesOf(dcs.device,dcs.device+'.'+dcs.channel,async function(err,obj) {
                     // Get all states for changed device.channel
-                    /*
-                    // Probalby better solution based on numbers as marker for arrays. But not working yet.
-                    function isNumber(value) { return /^\d+$/.test(value); }
-                    function insertDictSubVal(dict, keyArr, isArray, val) {
-                        if (keyArr.length == 1) {
-                            const key = keyArr[0];
-                            if (isArray) dict[key].push(val); else dict[key] = val;
-                        } else {
-                            const key = keyArr.shift();
-                            const nextIsArray = (((keyArr.length) && (isNumber(keyArr[0]))) ? true : false);
-                            if (!(key in dict)) if (nextIsArray) dict[key] = []; else dict[key] = {};
-                            insertDictSubVal(dict[key],keyArr, nextIsArray, val);
-                        }
-                    }
-                    */
                     function insertDictSubVal(dict, keyArr, val) {
                         const listLabels = ['ListEntries','Schedules','TopologyElement'];
                         if (keyArr.length == 1) {
@@ -437,12 +430,16 @@ class uds {
                             insertDictSubVal(treeDict, label.split('.'), val);
                         }
                     }
-                    byteArr = await ctxWorker.storage.encodeDataCAN(ctx, ctxWorker, did, treeDict);
-                    if (byteArr) {
-                        await ctxWorker.pushCmnd(ctx, 'write', [[did,byteArr]]);
-                        setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,ctxWorker,did);    // Read value after 2500 ms
-                    } else {
-                        ctx.log.error('User command UDS WriteByDid on '+ctxWorker.config.stateBase+': Encoding of data failed.');
+                    try {
+                        byteArr = await ctxWorker.storage.encodeDataCAN(ctx, ctxWorker, did, treeDict);
+                        if (byteArr) {
+                            await ctxWorker.pushCmnd(ctx, 'write', [[did,byteArr]]);
+                            setTimeout(function(ctxWorker,did){ctxWorker.cmndsQueue.push({'mode':'read', 'did': did});},2500,ctxWorker,did);    // Read value after 2500 ms
+                        } else {
+                            ctx.log.error('User command UDS WriteByDid on '+ctxWorker.config.stateBase+': Encoding of data failed.');
+                        }
+                    } catch(e) {
+                        ctx.log.error('WriteByDid(): Encoding of data failed on '+ctxWorker.config.stateBase+'.'+String(did)+'; err='+JSON.stringify(e));
                     }
                 });
                 break;

package/lib/codecs.js

@@ -205,18 +205,28 @@ class O3EUtf8 {
         this.id = idStr;
         this.offset = _args.offset;
     }
+
     encode(data) {
-        const encoder = new TextEncoder();
-        const result = Object.values(encoder.encode(data));
-        if (result.length > this.string_len) throw new Error('O3EUtf8.encode() result too long: '+this.id+' - '+String(result.length)+' > '+String(this.string_len));
+        let result;
+        try {
+            result = Object.values(new TextEncoder().encode(data));
+        } catch(e) {
+            throw new Error('O3EUtf8.encode(): Conversion from Utf8 failed '+this.id+'; err='+JSON.stringify(e));
+        }
+        if (result.length > this.string_len) throw new Error('O3EUtf8.encode(): Result too long: '+this.id+' - '+String(result.length)+' > '+String(this.string_len));
         return result.concat(Array.from(Array(this.string_len-result.length), () => 0));
 
     }
     decode(string_bin) {
-        let mystr = '';
-        for (let i=this.offset; i<this.offset+this.string_len;i++) { mystr += String.fromCharCode(string_bin[i]); }
-        // eslint-disable-next-line no-control-regex
-        return mystr.replace(/[\u0000-\u0008,\u000A-\u001F,\u007F-\u00A0]+/g, '');
+        let i = string_bin.slice(this.offset).indexOf(0);
+        if (i == -1) { i = string_bin.length-this.offset; }
+        let result;
+        try {
+            result = new TextDecoder().decode(new Uint8Array(string_bin.slice(this.offset,i)));
+        } catch(e) {
+            throw new Error('O3EUtf8.decode(): Conversion to Utf8 failed '+this.id+'; err='+JSON.stringify(e));
+        }
+        return result;
     }
 
     __len__() {

package/lib/codecs.test.js

@@ -38,6 +38,62 @@ function codecEncode(descr, expected, codec, len, id, args, val) {
     });
 }
 
+// Utf8:
+describe('codecs.js => O3EUtf8()', () => {
+    const raw_hex1 = '4865697a6bc3b6727065720000000000000000000000000000000000000000000000000000000000';
+    const raw1 = E3.toByteArray(raw_hex1);
+    const txt1 = 'Heizkörper';
+    it(`Decode ${JSON.stringify(txt1)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw1.length,'test1Utf08', {offset:0});
+        const result = f.decode(raw1);
+        expect(JSON.stringify(result)).to.equal(JSON.stringify(txt1));
+    });
+    it(`Encode ${JSON.stringify(raw1)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw1.length,'test2Utf08', {offset:0});
+        const result = f.encode(txt1);
+        expect(JSON.stringify(raw1)).to.equal(JSON.stringify(result));
+    });
+    const raw_hex2 = '4675c39f626f64656e6865697a756e67000000000000000000000000000000000000000000000000';
+    const raw2 = E3.toByteArray(raw_hex2);
+    const txt2 = 'Fußbodenheizung';
+    it(`Decode ${JSON.stringify(txt2)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw2.length,'test3Utf08', {offset:0});
+        const result = f.decode(raw2);
+        expect(JSON.stringify(result)).to.equal(JSON.stringify(txt2));
+    });
+    it(`Encode ${JSON.stringify(raw2)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw2.length,'test4Utf08', {offset:0});
+        const result = f.encode(txt2);
+        expect(JSON.stringify(raw2)).to.equal(JSON.stringify(result));
+    });
+    const raw_hex3 = '00000000000000000000000000000000000000000000000000000000000000000000000000000000';
+    const raw3 = E3.toByteArray(raw_hex3);
+    const txt3 = '';
+    it(`Decode ${JSON.stringify(txt3)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw3.length,'test5Utf08', {offset:0});
+        const result = f.decode(raw3);
+        expect(JSON.stringify(result)).to.equal(JSON.stringify(txt3));
+    });
+    it(`Encode ${JSON.stringify(raw3)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw3.length,'test5Utf08', {offset:0});
+        const result = f.encode(txt3);
+        expect(JSON.stringify(raw3)).to.equal(JSON.stringify(result));
+    });
+    const raw_hex4 = '4675c39f';
+    const raw4 = E3.toByteArray(raw_hex4);
+    const txt4 = 'Fuß';
+    it(`Decode ${JSON.stringify(txt4)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw4.length,'test6Utf08', {offset:0});
+        const result = f.decode(raw4);
+        expect(JSON.stringify(result)).to.equal(JSON.stringify(txt4));
+    });
+    it(`Encode ${JSON.stringify(raw4)}`, () => {
+        const f = new E3.O3Ecodecs.O3EUtf8(raw4.length,'test6Utf08', {offset:0});
+        const result = f.encode(txt4);
+        expect(JSON.stringify(raw4)).to.equal(JSON.stringify(result));
+    });
+});
+
 // val2byteArray:
 describe('codecs.js => val2byteArr()', () => {
     let val = -1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.e3oncan",
-  "version": "0.6.14",
+  "version": "0.6.15",
   "description": "Collect data on CAN bus for Viessmann E3 devices, e.g. Vitocal, Vitocharge, Energy Meter E380",
   "author": {
     "name": "Juergen",