Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. Daten Seriell von Paradigma Solaranlage lesen

    NEWS

    • Neuer Blog: Fotos und Eindrücke aus Solingen

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    Daten Seriell von Paradigma Solaranlage lesen

    This topic has been deleted. Only users with topic management privileges can see it.
    • G
      glitzi @AlCalzone last edited by

      @AlCalzone

      Kann ich dann einfach im on("data") mit „ schedule“ arbeiten?
      Möchte vermeiden das die Datenpunkte sich permanent aktualisieren und die influxdb zumüllen.

      AlCalzone 1 Reply Last reply Reply Quote 0
      • AlCalzone
        AlCalzone Developer @glitzi last edited by

        @glitzi Nein. Aber sowas geht:

        // außerhalb on("data"):
        let lastCheck = 0; // 0 sorgt dafür, dass gleich zu Beginn einmal ausgelesen wird
        
        // innerhalb on("data"):
        if (Date.now() - lastCheck < 30000) return;
        lastCheck = Date.now();
        //... übliche Auswertung
        1 Reply Last reply Reply Quote 0
        • G
          glitzi @AlCalzone last edited by glitzi

          @AlCalzone sagte in Daten Seriell von Paradigma Solaranlage lesen:

          @glitzi sagte in Daten Seriell von Paradigma Solaranlage lesen:

          Ok, werde mal lesen wie ich das mache... muss ich den alten vorher löschen? Was passiert dabei mit den Skripten?

          https://www.iobroker.net/#de/documentation/tutorial/adapter.md?dieinstallationvongithub

          Einfach nur über das GitHub-Icon installieren, die Skripte bleiben erhalten.

          Ich habe jetzt über den Expertenmodus Installiert..

          b3014c2d-8d92-4cd8-89db-8df79074730b-image.png
          einmal hinten das + und dann die aktuell Version, aber der Fehler kommt trotzdem.
          Ich habe auch den Pfeil Upload probiert, was passiert da eigentlich?

          30.11.2020, 16:51:37.077	[info ]: javascript.0 (16580) Stop script script.js.Paradigma.TEST_Parser
          30.11.2020, 16:51:37.094	[info ]: javascript.0 (16580) Start javascript script.js.Paradigma.TEST_Parser
          30.11.2020, 16:51:37.107	[error]: javascript.0 (16580) script.js.Paradigma.TEST_Parser: Error: Cannot find module '/opt/iobroker/node_modules/iobroker.javascript/lib/../../stream'
          30.11.2020, 16:51:37.109	[error]: javascript.0 (16580)     at script.js.Paradigma.TEST_Parser:18:23
          30.11.2020, 16:51:37.112	[error]: javascript.0 (16580) script.js.Paradigma.TEST_Parser: script.js.Paradigma.TEST_Parser:18
          30.11.2020, 16:51:37.114	[error]: javascript.0 (16580)     at script.js.Paradigma.TEST_Parser:18:9
          
          javascript.0	2020-11-30 17:01:24.798	error	(16878) at Script.runInContext (vm.js:130:18)
          javascript.0	2020-11-30 17:01:24.798	error	(16878) at script.js.Paradigma.TEST_Parser:18:9
          javascript.0	2020-11-30 17:01:24.797	error	(16878) TypeError: Cannot destructure property 'Transform' of 'require(...)' as it is undefined.
          javascript.0	2020-11-30 17:01:24.797	error	(16878) ^
          javascript.0	2020-11-30 17:01:24.796	error	(16878) const { Transform } = require('stream');
          javascript.0	2020-11-30 17:01:24.796	error	(16878) script.js.Paradigma.TEST_Parser: script.js.Paradigma.TEST_Parser:18
          javascript.0	2020-11-30 17:01:24.792	error	(16878) at Script.runInContext (vm.js:130:18)
          javascript.0	2020-11-30 17:01:24.792	error	(16878) at script.js.Paradigma.TEST_Parser:18:23
          javascript.0	2020-11-30 17:01:24.791	error	(16878) at require (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:389:36)
          javascript.0	2020-11-30 17:01:24.791	error	(16878) at require (internal/modules/cjs/helpers.js:74:18)
          javascript.0	2020-11-30 17:01:24.790	error	(16878) at Module.require (internal/modules/cjs/loader.js:903:19)
          javascript.0	2020-11-30 17:01:24.790	error	(16878) script.js.Paradigma.TEST_Parser: Error: Cannot find module '/opt/iobroker/node_modules/iobroker.javascript/lib/../../stream'
          
          
          AlCalzone 1 Reply Last reply Reply Quote 0
          • AlCalzone
            AlCalzone Developer @glitzi last edited by

            @glitzi sagte in Daten Seriell von Paradigma Solaranlage lesen:

            einmal hinten das + und dann die aktuell Version

            Das ist zwar normalerweise korrekt, aber diesmal ist die Installation von Github nötig, weil der Fix noch nicht als Version veröffentlicht wurde.

            1.:
            d95b37f4-2418-49c9-ac04-f8ebeb0d3087-grafik.png

            2.:
            d599b64d-b660-4eaf-b3ce-532a0b42c5d2-grafik.png

            G 1 Reply Last reply Reply Quote 0
            • G
              glitzi @AlCalzone last edited by

              @AlCalzone

              Vom Github ist installiert, Version 4.10.6

              Sobald das Skrip läuft, stürzt die Instanz von Java ohne Meldungen im Log ab,

              
              const Delimiter = require('@serialport/parser-delimiter')
              const Ready = require('@serialport/parser-ready')
              
              createState('Paradigma_Kollektor');
              createState('Paradigma_Speichertemperatur');
              createState('Paradigma_Solarvorlauf');
              createState('Paradigma_Aussentemperatur');
              createState('Paradigma_Solarrücklauf');
              createState('Paradigma_Durchfluss');
              createState('Paradigma_PWMPumpe');
              createState('Paradigma_Tagesleistung');
              createState('Paradigma_Gesamtleistung');
              createState('Paradigma_Status');
              createState('Paradigma_StatusText');
              createState('Paradigma_Fehlercode');
              createState('Paradigma_FehlercodeText');
               
              const { Transform } = require('stream');
               
              class PreambleParser extends Transform {
              	/**
              	 * @param {Buffer} preamble
              	 * @param {number} payloadLength
              	 */
              	constructor(preamble, payloadLength) {
              		super();
              		this.receiveBuffer = Buffer.allocUnsafe(0);
              		this.preamble = preamble;
              		this.payloadLength = payloadLength;
              	}
               
              	_transform(chunk, encoding, callback) {
              		this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
               
              		while (this.receiveBuffer.length >= this.preamble.length) {
              			// Check if the buffer starts with the preamble
              			const preambleIndex = this.receiveBuffer.indexOf(this.preamble);
              			if (preambleIndex === -1) {
              				// not found, wait for the next chunk
              				break;
              			}
              			// Skip bytes before the preamble
              			this.receiveBuffer = skipBytes(this.receiveBuffer, preambleIndex);
               
              			// Check if we still have enough data
              			if (
              				this.receiveBuffer.length >=
              				this.preamble.length + this.payloadLength
              			) {
              				// Yes, emit it
              				this.push(
              					this.receiveBuffer.slice(
              						this.preamble.length,
              						this.preamble.length + this.payloadLength,
              					),
              				);
              				// And skip the bytes
              				this.receiveBuffer = skipBytes(
              					this.receiveBuffer,
              					this.preamble.length + this.payloadLength,
              				);
              			}
              		}
              		callback();
              	}
              }
               
              /** Skips the first n bytes of a buffer and returns the rest */
              function skipBytes(buf, n) {
              	return Buffer.from(buf.slice(n));
              }
               
              // ---
               
              const parser = new PreambleParser(
              	Buffer.from("fc3e2401", "hex"), // Start der Datenpakete
              	38, // Wie viele Bytes nach dem Start ausgewertet werden
              );
              
              parser.on('data', chunk => {
              
                  console.log(chunk.toString("hex"));
              
              	
              
              });
              
              // Bei jedem Dateneingang:
               
              const hexDatenOhneLeerzeichen =
              	"0120000233fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
               
              parser.write(hexDatenOhneLeerzeichen, "hex");
              
              
              AlCalzone 1 Reply Last reply Reply Quote 0
              • AlCalzone
                AlCalzone Developer @glitzi last edited by

                @glitzi sagte in Daten Seriell von Paradigma Solaranlage lesen:

                stürzt die Instanz von Java ohne Meldungen im Log ab

                woran machst du das fest?

                Außerdem: die letzten Dinge, die wir besprochen hatten, sind doch gar nicht drin?

                G 1 Reply Last reply Reply Quote 0
                • G
                  glitzi @AlCalzone last edited by

                  @AlCalzone

                  ja die Änderungen sind nicht drin, habe mal alles weggelassen um den Fehler einzugrenzen.

                  Wie stelle ich das fest:

                  • im Editor kommt Instanz ist nicht aktiv oder so ähnlich.

                  • bei den Instanzen im Admin wird das Lämpchen orange (Lebenszeichen und Verbunden gehen in Fehler)

                  • Nach einem Neustart über den Button geht es wieder bis ich das Skript wieder neu starte, danach das gleiche Spiel.

                  • CPU Last, sonst liege ich unter 1%, nach mehrere Abstürzen von javaskript.0 steigert sich die Last auf 10%. Nach einem Neustart von ioBroker wieder alles unter 1%

                  AlCalzone 1 Reply Last reply Reply Quote 0
                  • AlCalzone
                    AlCalzone Developer @glitzi last edited by

                    @glitzi Dann muss irgendetwas im normalen ioBroker-Log stehen.

                    G 1 Reply Last reply Reply Quote 0
                    • G
                      glitzi @AlCalzone last edited by

                      @AlCalzone

                      Im Editor nach ca. 20 Sekunden
                      55284ca8-6031-424e-924d-db3e3a29bb52-image.png

                      LOG ist Leer
                      8afe1e48-d1a9-4c75-b5e8-8d035ce4dd2b-image.png

                      Instanzen
                      6704fe52-36b1-4931-89a0-ae644c692730-image.png

                      AlCalzone 1 Reply Last reply Reply Quote 0
                      • AlCalzone
                        AlCalzone Developer @glitzi last edited by

                        @glitzi Da ist dann was ganz im Argen. Leeres Log ist in der Regel nicht gut. Mach doch mal den Log in einem zweiten Browser-Fenster auf und beobachte da, was passiert wenn du das Skript startest.

                        G 1 Reply Last reply Reply Quote 0
                        • G
                          glitzi @AlCalzone last edited by

                          @AlCalzone

                          man kann leider auch im zweiten Fenster nichts sehen...

                          AlCalzone 1 Reply Last reply Reply Quote 0
                          • AlCalzone
                            AlCalzone Developer @glitzi last edited by

                            @glitzi Auch nicht bevor du das Skript startest?

                            G 1 Reply Last reply Reply Quote 0
                            • G
                              glitzi @AlCalzone last edited by

                              @AlCalzone

                              Doch klar, vor dem Start habe ich es gelöscht um einfacher zu sehn ob etwas kommt.

                              AlCalzone 1 Reply Last reply Reply Quote 0
                              • AlCalzone
                                AlCalzone Developer @glitzi last edited by

                                @glitzi Hmm aber einen Absturz sollte man im Log sehen.

                                G 1 Reply Last reply Reply Quote 0
                                • G
                                  glitzi @AlCalzone last edited by glitzi

                                  @AlCalzone

                                  Jetzt habe fast ich eine LÖSUNG:

                                  Mir Readline funktioniert es!

                                  Es kommt nur dieser Fehler wenn ich einzelne Teile auswerte und in einen Datenpunkt schreiben will, scheint was mit der Konvertierung zu sein?

                                  21:25:38.455	info	javascript.0 (7696) Stop script script.js.Paradigma.verworfen_Serielle_Daten_von_Paradigma_lesen
                                  21:25:39.521	info	javascript.0 (7696) Start javascript script.js.Paradigma.verworfen_Serielle_Daten_von_Paradigma_lesen
                                  21:25:39.528	info	javascript.0 (7696) script.js.Paradigma.verworfen_Serielle_Daten_von_Paradigma_lesen: registered 0 subscriptions and 0 schedules
                                  21:25:39.927	info	javascript.0 (7696) script.js.Paradigma.verworfen_Serielle_Daten_von_Paradigma_lesen: 3c005402aa00feff00003c0100000000000100010c001519020c14410000000000414400000000000000000000003c00000000000000000000000000cb
                                  21:25:39.929	error	javascript.0 (7696) script.js.Paradigma.verworfen_Serielle_Daten_von_Paradigma_lesen: TypeError: chunk.readUInt16LE is not a function
                                  21:25:39.929	error	javascript.0 (7696) at ReadLineParser.<anonymous> (script.js.Paradigma.verworfen_Serielle_Daten_von_Paradigma_lesen:35:14)
                                  
                                  const SerialPort = require('serialport')
                                  const Readline = require('@serialport/parser-readline')
                                  const port = new SerialPort('/dev/ttyUSB0')
                                  
                                  createState('Paradigma_Kollektor');
                                  createState('Paradigma_Speichertemperatur');
                                  createState('Paradigma_Solarvorlauf');
                                  createState('Paradigma_Aussentemperatur');
                                  createState('Paradigma_Solarrücklauf');
                                  createState('Paradigma_Durchfluss');
                                  createState('Paradigma_PWMPumpe');
                                  createState('Paradigma_Tagesleistung');
                                  createState('Paradigma_Gesamtleistung');
                                  createState('Paradigma_Status');
                                  createState('Paradigma_StatusText');
                                  createState('Paradigma_Fehlercode');
                                  createState('Paradigma_FehlercodeText');
                                  
                                  const parser = port.pipe(new Readline({ delimiter: 'fc3e2401', encoding: 'HEX' }))
                                  
                                  parser.on('data', chunk => {
                                  
                                      if (Date.now() - lastCheck < 10000) return;
                                      lastCheck = Date.now();
                                  
                                      console.log(chunk.toString("hex"));
                                  
                                  	val = chunk.readUInt16LE(0) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                      setState('Paradigma_Kollektor', val /10, true);
                                  
                                  
                                  });
                                  
                                  
                                  let lastCheck = 0; // 0 sorgt dafür, dass gleich zu Beginn einmal ausgelesen wird
                                   
                                  
                                  // Port bei Skriptende schließen:
                                  onStop(() => {
                                    port.close();
                                  });
                                  
                                  AlCalzone 1 Reply Last reply Reply Quote 0
                                  • AlCalzone
                                    AlCalzone Developer @glitzi last edited by AlCalzone

                                    @glitzi sagte in Daten Seriell von Paradigma Solaranlage lesen:

                                    chunk.readUInt16LE is not a function

                                    Readline liest Text, die Funktion erwartet einen Buffer. Der Readline-Parser ist auch nur eine spezielle Variante des Delimiter-Parsers, d.h. er gibt dir zurück, was vor deinem Code kommt, nicht das danach.

                                    Ich verstehe nicht warum das andere nicht gehen soll. Es muss doch irgendwo irgendwas stehen. Zeig mir bitte mal das vollständige Skript mit dem anderen Parser.

                                    G 1 Reply Last reply Reply Quote 0
                                    • G
                                      glitzi @AlCalzone last edited by

                                      @AlCalzone

                                      wie kann man denn den Text verarbeiten, mit Readline würde es ja gehen!

                                      Anbei das andere Skript:

                                      const Delimiter = require('@serialport/parser-delimiter')
                                      const Ready = require('@serialport/parser-ready')
                                      
                                      createState('Paradigma_Kollektor');
                                      createState('Paradigma_Speichertemperatur');
                                      createState('Paradigma_Solarvorlauf');
                                      createState('Paradigma_Aussentemperatur');
                                      createState('Paradigma_Solarrücklauf');
                                      createState('Paradigma_Durchfluss');
                                      createState('Paradigma_PWMPumpe');
                                      createState('Paradigma_Tagesleistung');
                                      createState('Paradigma_Gesamtleistung');
                                      createState('Paradigma_Status');
                                      createState('Paradigma_StatusText');
                                      createState('Paradigma_Fehlercode');
                                      createState('Paradigma_FehlercodeText');
                                       
                                      const { Transform } = require('stream');
                                       
                                      class PreambleParser extends Transform {
                                      	/**
                                      	 * @param {Buffer} preamble
                                      	 * @param {number} payloadLength
                                      	 */
                                      	constructor(preamble, payloadLength) {
                                      		super();
                                      		this.receiveBuffer = Buffer.allocUnsafe(0);
                                      		this.preamble = preamble;
                                      		this.payloadLength = payloadLength;
                                      	}
                                       
                                      	_transform(chunk, encoding, callback) {
                                      		this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
                                       
                                      		while (this.receiveBuffer.length >= this.preamble.length) {
                                      			// Check if the buffer starts with the preamble
                                      			const preambleIndex = this.receiveBuffer.indexOf(this.preamble);
                                      			if (preambleIndex === -1) {
                                      				// not found, wait for the next chunk
                                      				break;
                                      			}
                                      			// Skip bytes before the preamble
                                      			this.receiveBuffer = skipBytes(this.receiveBuffer, preambleIndex);
                                       
                                      			// Check if we still have enough data
                                      			if (
                                      				this.receiveBuffer.length >=
                                      				this.preamble.length + this.payloadLength
                                      			) {
                                      				// Yes, emit it
                                      				this.push(
                                      					this.receiveBuffer.slice(
                                      						this.preamble.length,
                                      						this.preamble.length + this.payloadLength,
                                      					),
                                      				);
                                      				// And skip the bytes
                                      				this.receiveBuffer = skipBytes(
                                      					this.receiveBuffer,
                                      					this.preamble.length + this.payloadLength,
                                      				);
                                      			}
                                      		}
                                      		callback();
                                      	}
                                      }
                                       
                                      /** Skips the first n bytes of a buffer and returns the rest */
                                      function skipBytes(buf, n) {
                                      	return Buffer.from(buf.slice(n));
                                      }
                                       
                                      // ---
                                       
                                      const parser = new PreambleParser(
                                      	Buffer.from("fc3e2401", "hex"), // Start der Datenpakete
                                      	38, // Wie viele Bytes nach dem Start ausgewertet werden
                                      );
                                      
                                      parser.on('data', chunk => {
                                      
                                          console.log(chunk.toString("hex"));
                                      
                                      	
                                      
                                      });
                                      
                                      // Bei jedem Dateneingang:
                                       
                                      const hexDatenOhneLeerzeichen =
                                      	"0120000233fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                                       
                                      parser.write(hexDatenOhneLeerzeichen, "hex");
                                      
                                      
                                      AlCalzone 1 Reply Last reply Reply Quote 0
                                      • AlCalzone
                                        AlCalzone Developer @glitzi last edited by

                                        @glitzi Fehler gefunden - da hatte sich eine Endlosschleife eingeschlichen.

                                        Anbei dein Skript mit 2 kleinen Änderungen.

                                        1. Die beiden Parser am Anfang brauchst du nicht importieren, wenn du sie nicht nutzt
                                        2. else in Zeile 59-61 eingefügt
                                        createState("Paradigma_Kollektor");
                                        createState("Paradigma_Speichertemperatur");
                                        createState("Paradigma_Solarvorlauf");
                                        createState("Paradigma_Aussentemperatur");
                                        createState("Paradigma_Solarrücklauf");
                                        createState("Paradigma_Durchfluss");
                                        createState("Paradigma_PWMPumpe");
                                        createState("Paradigma_Tagesleistung");
                                        createState("Paradigma_Gesamtleistung");
                                        createState("Paradigma_Status");
                                        createState("Paradigma_StatusText");
                                        createState("Paradigma_Fehlercode");
                                        createState("Paradigma_FehlercodeText");
                                        
                                        const { Transform } = require("stream");
                                        
                                        class PreambleParser extends Transform {
                                          /**
                                           * @param {Buffer} preamble
                                           * @param {number} payloadLength
                                           */
                                          constructor(preamble, payloadLength) {
                                            super();
                                            this.receiveBuffer = Buffer.allocUnsafe(0);
                                            this.preamble = preamble;
                                            this.payloadLength = payloadLength;
                                          }
                                        
                                          _transform(chunk, encoding, callback) {
                                            this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
                                        
                                            while (this.receiveBuffer.length >= this.preamble.length) {
                                              // Check if the buffer starts with the preamble
                                              const preambleIndex = this.receiveBuffer.indexOf(this.preamble);
                                              if (preambleIndex === -1) {
                                                // not found, wait for the next chunk
                                                break;
                                              }
                                              // Skip bytes before the preamble
                                              this.receiveBuffer = skipBytes(this.receiveBuffer, preambleIndex);
                                        
                                              // Check if we still have enough data
                                              if (
                                                this.receiveBuffer.length >=
                                                this.preamble.length + this.payloadLength
                                              ) {
                                                // Yes, emit it
                                                this.push(
                                                  this.receiveBuffer.slice(
                                                    this.preamble.length,
                                                    this.preamble.length + this.payloadLength
                                                  )
                                                );
                                                // And skip the bytes
                                                this.receiveBuffer = skipBytes(
                                                  this.receiveBuffer,
                                                  this.preamble.length + this.payloadLength
                                                );
                                              } else {
                                                // no, wait until we do
                                                break;
                                              }
                                            }
                                            callback();
                                          }
                                        }
                                        
                                        /** Skips the first n bytes of a buffer and returns the rest */
                                        function skipBytes(buf, n) {
                                          return Buffer.from(buf.slice(n));
                                        }
                                        
                                        // ---
                                        
                                        const parser = new PreambleParser(
                                          Buffer.from("fc3e2401", "hex"), // Start der Datenpakete
                                          38 // Wie viele Bytes nach dem Start ausgewertet werden
                                        );
                                        
                                        parser.on("data", (chunk) => {
                                          console.log(chunk.toString("hex"));
                                        });
                                        
                                        // Bei jedem Dateneingang:
                                        
                                        const hexDatenOhneLeerzeichen =
                                          "0120000233fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                                        
                                        parser.write(hexDatenOhneLeerzeichen, "hex");
                                        
                                        G 1 Reply Last reply Reply Quote 0
                                        • G
                                          glitzi @AlCalzone last edited by glitzi

                                          @AlCalzone

                                          Es ist vollbracht 👍

                                          es Funktioniert DANKE!!!!! Ein besonderes Dankeschön an @AlCalzone!

                                          Hier das Fertige Skript für alle Paradigma Nutzer die sich über folgenden Link einen Adapter gelötet haben.

                                          Seite mit Bauanleitung:

                                          createState("Paradigma_Kollektor");
                                          createState("Paradigma_Speichertemperatur");
                                          createState("Paradigma_Solarvorlauf");
                                          createState("Paradigma_Aussentemperatur");
                                          createState("Paradigma_Solarrücklauf");
                                          createState("Paradigma_Durchfluss");
                                          createState("Paradigma_PWMPumpe");
                                          createState("Paradigma_Tagesleistung");
                                          createState("Paradigma_Gesamtleistung");
                                          createState("Paradigma_Status");
                                          createState("Paradigma_StatusText");
                                          createState("Paradigma_Fehlercode");
                                          createState("Paradigma_FehlercodeText");
                                           
                                          const { Transform } = require("stream");
                                           
                                          class PreambleParser extends Transform {
                                            /**
                                             * @param {Buffer} preamble
                                             * @param {number} payloadLength
                                             */
                                            constructor(preamble, payloadLength) {
                                              super();
                                              this.receiveBuffer = Buffer.allocUnsafe(0);
                                              this.preamble = preamble;
                                              this.payloadLength = payloadLength;
                                            }
                                           
                                            _transform(chunk, encoding, callback) {
                                              this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
                                           
                                              while (this.receiveBuffer.length >= this.preamble.length) {
                                                // Check if the buffer starts with the preamble
                                                const preambleIndex = this.receiveBuffer.indexOf(this.preamble);
                                                if (preambleIndex === -1) {
                                                  // not found, wait for the next chunk
                                                  break;
                                                }
                                                // Skip bytes before the preamble
                                                this.receiveBuffer = skipBytes(this.receiveBuffer, preambleIndex);
                                           
                                                // Check if we still have enough data
                                                if (
                                                  this.receiveBuffer.length >=
                                                  this.preamble.length + this.payloadLength
                                                ) {
                                                  // Yes, emit it
                                                  this.push(
                                                    this.receiveBuffer.slice(
                                                      this.preamble.length,
                                                      this.preamble.length + this.payloadLength
                                                    )
                                                  );
                                                  // And skip the bytes
                                                  this.receiveBuffer = skipBytes(
                                                    this.receiveBuffer,
                                                    this.preamble.length + this.payloadLength
                                                  );
                                                } else {
                                                  // no, wait until we do
                                                  break;
                                                }
                                              }
                                              callback();
                                            }
                                          }
                                           
                                          /** Skips the first n bytes of a buffer and returns the rest */
                                          function skipBytes(buf, n) {
                                            return Buffer.from(buf.slice(n));
                                          }
                                           
                                          // ---
                                           
                                          const parser = new PreambleParser(
                                            Buffer.from("fc3e2401", "hex"), // Start der Datenpakete
                                            38 // Wie viele Bytes nach dem Start ausgewertet werden
                                          );
                                           
                                          parser.on("data", (chunk) => {
                                           
                                          if (Date.now() - lastCheck < 30000) return;
                                              lastCheck = Date.now();
                                           
                                              //console.log(chunk.toString("hex"));
                                           
                                          	val = chunk.readUInt16LE(0) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Kollektor', val /10, true);
                                          
                                              val = chunk.readUInt16LE(2) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Speichertemperatur', val /10, true);
                                          
                                              val = chunk.readUInt16LE(4) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Solarvorlauf', val /10, true);
                                          
                                              val = chunk.readInt16LE(6) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Aussentemperatur', val /10, true);
                                          
                                              val = chunk.readUInt16LE(10) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Solarrücklauf', val /10, true);
                                          
                                              val = chunk.readUInt16LE(12) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Durchfluss', val /10, true);
                                          
                                              val = chunk.readUInt8(14) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_PWMPumpe', val /10, true);
                                          
                                              val = chunk.readUInt16LE(29) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Tagesleistung', val , true);
                                          
                                              val = chunk.readUInt16LE(32) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Gesamtleistung', val , true);
                                          
                                              val = chunk.readUInt8(17) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Status', val, true);
                                          
                                          switch(val) {
                                            case 0:
                                              setState('Paradigma_StatusText', 'Warten auf Sonne', true);
                                              break;
                                            case 1:
                                              setState('Paradigma_StatusText', 'Frostschutz', true);
                                              break;
                                            case 2:
                                              setState('Paradigma_StatusText', 'Anschieben', true);
                                              break;
                                            case 3:
                                              setState('Paradigma_StatusText', 'Einschaltverzögerung', true);
                                              break;
                                            case 4:
                                              setState('Paradigma_StatusText', 'erwärmt Speicher', true);
                                              break;
                                            case 5:
                                              setState('Paradigma_StatusText', 'Speicher voll', true);
                                              break;
                                            case 6:
                                              setState('Paradigma_StatusText', 'Kollektor überhitzt', true);
                                              break;
                                            case 7:
                                              setState('Paradigma_StatusText', 'Hand, Test oder Aus', true);
                                              break;
                                            case 8:
                                              setState('Paradigma_StatusText', 'Messung', true);
                                              break;
                                             default:
                                              setState('Paradigma_StatusText', val, true);
                                          }
                                          
                                              val = chunk.readUInt8(18) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                              setState('Paradigma_Fehlercode', val, true);
                                              
                                          switch(val) {
                                            case 0:
                                              setState('Paradigma_FehlercodeText', 'OK', true);
                                              break;
                                            case 1:
                                              setState('Paradigma_FehlercodeText', 'Kein Volumenstrom', true);
                                              break;
                                            case 2:
                                              setState('Paradigma_FehlercodeText', 'Luft in der Anlage', true);
                                              break;
                                            case 4:
                                              setState('Paradigma_FehlercodeText', 'Vor- u. Rücklauf vertauscht', true);
                                              break;
                                            case 5:
                                              setState('Paradigma_FehlercodeText', 'Zonenventil defekt', true);
                                              break;
                                            case 6:
                                              setState('Paradigma_FehlercodeText', 'Falsche Uhrzeit', true);
                                              break;
                                            case 7:
                                              setState('Paradigma_FehlercodeText', 'Druckabfall in der Anlage', true);
                                              break;
                                            case 9:
                                              setState('Paradigma_FehlercodeText', 'Falsche Hydraulik', true);
                                              break;
                                            case 10:
                                              setState('Paradigma_FehlercodeText', 'Rohrisolierung', true);
                                              break;
                                            case 11:
                                              setState('Paradigma_FehlercodeText', 'Stromversorgung n. konstant', true);
                                              break;
                                            case 12:
                                              setState('Paradigma_FehlercodeText', 'OLV defekt', true);
                                              break;
                                            case 13:
                                              setState('Paradigma_FehlercodeText', 'Zu wenig Volumenstrom', true);
                                              break;
                                            case 14:
                                              setState('Paradigma_FehlercodeText', 'Speicher unterkühlt durch Frostschutz', true);
                                              break;
                                            case 20:
                                              setState('Paradigma_FehlercodeText', 'Fühler Außentemperatur falsch montiert', true);
                                              break;
                                            case 21:
                                              setState('Paradigma_FehlercodeText', 'Ausfall Kollektorfühler', true);
                                              break;
                                            case 22:
                                              setState('Paradigma_FehlercodeText', 'Ausfall Fühler Solarrücklauf', true);
                                              break;
                                            case 23:
                                              setState('Paradigma_FehlercodeText', 'Störung Kollektrofühler', true);
                                              break;
                                            case 24:
                                              setState('Paradigma_FehlercodeText', 'Frostschutz', true);
                                              break;
                                            case 25:
                                              setState('Paradigma_FehlercodeText', 'Fühler TSA u. TAM vertauscht', true);
                                              break;
                                            case 26:
                                              setState('Paradigma_FehlercodeText', 'Ausfall Fühler Solarvorlauf', true);
                                              break;
                                            case 27:
                                              setState('Paradigma_FehlercodeText', 'Ausfall Fühler Außentemperatur', true);
                                              break;
                                            case 34:
                                              setState('Paradigma_FehlercodeText', 'Überhitzung Speicher 1', true);
                                              break;
                                            case 35:
                                              setState('Paradigma_FehlercodeText', 'Überhitzung Speicher 2', true);
                                              break;
                                            case 49:
                                              setState('Paradigma_FehlercodeText', 'Solarstation unterkühlt', true);
                                              break;
                                            case 50:
                                              setState('Paradigma_FehlercodeText', 'Kollektor eingefroren', true);
                                              break;
                                             default:
                                              setState('Paradigma_FehlercodeText', val, true);
                                          
                                          }
                                           
                                          });
                                           
                                          let lastCheck = 0; // 0 sorgt dafür, dass gleich zu Beginn einmal ausgelesen wird
                                           
                                           const SerialPort = require('serialport');
                                           
                                          // Port öffnen
                                          const port = new SerialPort('/dev/ttyUSB0');
                                          port.pipe(parser);
                                           
                                          // Port bei Skriptende schließen:
                                          onStop(() => {
                                            port.close();
                                          });
                                          
                                          1 Reply Last reply Reply Quote 0
                                          • First post
                                            Last post

                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          559
                                          Online

                                          31.9k
                                          Users

                                          80.2k
                                          Topics

                                          1.3m
                                          Posts

                                          communication heating javascript
                                          3
                                          53
                                          4416
                                          Loading More Posts
                                          • Oldest to Newest
                                          • Newest to Oldest
                                          • Most Votes
                                          Reply
                                          • Reply as topic
                                          Log in to reply
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                          The ioBroker Community 2014-2023
                                          logo