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 last edited by glitzi

      Hallo,

      ich habe den Bus meiner Solaranlage seriell angezapft und lese aktuell über OpenHAB die Daten aus.

      Dazu habe ich auch eine "rule" in OpenHAB die mir die Daten aufbereitet.

      Kann mir jemand helfen das Script in ioBroker (JS) zu implementieren?

      Die Daten kommen in HEX von der Schnittstelle uns müssen dann zerlegt und umgerechnet werden.

      Mein Ziel ist es komplett auf ioBroker umzustellen und openHAB aufzugeben.

      Anbei die Quelle aus OpenHAB:

      Thing der Quelle:

      // Paradigma über serielle Schnittstelle
      Thing exec:command:Solar [command="od -t x1 -w512 -N512 /dev/ttyUSB0", interval=10, timeout=5, transform="REGEX((.*))"]
      

      Rule zur Datenverarbeitung:

      // #########################################################
      // #########################################################
      //Paradigma Daten auswerten
      // #########################################################
      // #########################################################
      
      rule "Paradigma"
      when  
          Item SolarRAW changed or
      	Time cron "0 * * * * ?"
      then
      
      //var String text = "0000000 29 fc 3e 24 01 e5 01 51 03 4a 01 fd 00 00 00 b0 01 00 00 00 00 00 05 00 00 00 00 13 28 1d 08 12 6c 00 0b 00 00 "
      var String text = SolarRAW.toString
      val String match = "fc 3e 24 01"
      
      var String[] buffer
      var Number wert
      var Integer position
      
          position = text.indexOf(match)
          if (position == 0) return
          
      logInfo("rule","test: an Position: " + position.toString)
          
          text = text.substring(position)
          
      // logInfo("rule","test: neuer text: " + text)  //ergibt: fc 3e 24 01 ...
          buffer= text.split(" ")
          
          wert = ((Integer::parseInt(buffer.get(5),16) * 256) +
                  (Integer::parseInt(buffer.get(4),16))).floatValue / 10
      			PS_Kollektor.postUpdate (wert)
          
      	wert = ((Integer::parseInt(buffer.get(7),16) * 256) +
                  (Integer::parseInt(buffer.get(6),16))).floatValue / 10
      			PS_Speicher.postUpdate (wert)
      			
      	wert = ((Integer::parseInt(buffer.get(9),16) * 256) +
                  (Integer::parseInt(buffer.get(8),16))).floatValue / 10
      			PS_Solarvorlauf.postUpdate (wert)
      			
      	wert = ((Integer::parseInt(buffer.get(11),16) * 256) +
                  (Integer::parseInt(buffer.get(10),16))).floatValue
      			if (wert >= 32768)
      			{
      			wert = (wert -65536) / 10 
      			PS_Aussen.postUpdate (wert)
      			}
      			else
      			{
      			wert = wert / 10
              	PS_Aussen.postUpdate (wert)
      			}
      			
      	wert = ((Integer::parseInt(buffer.get(15),16) * 256) +
                  (Integer::parseInt(buffer.get(14),16))).floatValue / 10
      			PS_Solarruecklauf.postUpdate (wert)
      			
      	wert = ((Integer::parseInt(buffer.get(17),16) * 256) +
                  (Integer::parseInt(buffer.get(16),16))).floatValue / 10
      			PS_Durchfluss.postUpdate (wert)
      			
      	wert = (Integer::parseInt(buffer.get(18),16)).floatValue
      			PS_PWMPumpe.postUpdate (wert)
      			
      	wert = ((Integer::parseInt(buffer.get(34),16) * 256) +
                  (Integer::parseInt(buffer.get(33),16))).floatValue
      			PS_Tagesleistung.postUpdate (wert)
      			
      	wert = ((Integer::parseInt(buffer.get(38),16) * 256) +
                  (Integer::parseInt(buffer.get(37),16))).floatValue
      			PS_Gesamtleistung.postUpdate (wert) 
      
      	wert = (Integer::parseInt(buffer.get(21),16)).floatValue
      			PS_Status0.postUpdate (wert)
      			
       	switch	(wert.toString) {
      					case "0.0"  : PS_Status0txt.postUpdate ("Warten auf Sonne")
      					case "1.0"  : PS_Status0txt.postUpdate ("Frostschutz")
      					case "2.0"  : PS_Status0txt.postUpdate ("Anschieben")
      					case "3.0"  : PS_Status0txt.postUpdate ("Einschaltverzögerung")
      					case "4.0"  : PS_Status0txt.postUpdate ("erwärmt Speicher")
      					case "5.0"  : PS_Status0txt.postUpdate ("Speicher voll")
      					case "6.0"  : PS_Status0txt.postUpdate ("Kollektor überhitzt")
      					case "7.0"  : PS_Status0txt.postUpdate ("Hand, Test oder Aus")
      					case "8.0"  : PS_Status0txt.postUpdate ("Messung")
      					default : PS_Status0txt.postUpdate (wert.toString)
      					}
      
      	wert = (Integer::parseInt(buffer.get(23),16)).floatValue
      			PS_Status1.postUpdate (wert)
      
       	switch	(wert.toString){
      					case "0.0"  : PS_Status1txt.postUpdate ("--")
      					case "1.0"  : PS_Status1txt.postUpdate ("Kein Volumenstrom")
      					case "2.0"  : PS_Status1txt.postUpdate ("Luft in der Anlage")
      					case "4.0"  : PS_Status1txt.postUpdate ("Vor- u. Rücklauf vertauscht")
      					case "5.0"  : PS_Status1txt.postUpdate ("Zonenventil defekt")
      					case "6.0"  : PS_Status1txt.postUpdate ("Falsche Uhrzeit")
      					case "7.0"  : PS_Status1txt.postUpdate ("Druckabfall in der Anlage")
      					case "9.0"  : PS_Status1txt.postUpdate ("Falsche Hydraulik")
      					case "10.0"  : PS_Status1txt.postUpdate ("Rohrisolierung")
      					case "11.0"  : PS_Status1txt.postUpdate ("Stromversorgung n. konstant")
      					case "12.0"  : PS_Status1txt.postUpdate ("OLV defekt")
      					case "13.0"  : PS_Status1txt.postUpdate ("Zu wenig Volumenstrom")
      					case "14.0"  : PS_Status1txt.postUpdate ("Speicher unterkühlt durch Frostschutz")
      					case "20.0"  : PS_Status1txt.postUpdate ("Fühler Außentemperatur falsch montiert")
      					case "21.0"  : PS_Status1txt.postUpdate ("Volumenstromsensor defekt")
      					case "22.0"  : PS_Status1txt.postUpdate ("Ausfall Kollektorfühler")
      					case "23.0"  : PS_Status1txt.postUpdate ("Ausfall Fühler Solarrücklauf")
      					case "24.0"  : PS_Status1txt.postUpdate ("Störung Kollektrofühler")
      					case "25.0"  : PS_Status1txt.postUpdate ("Fühler TSA u. TAM vertauscht")
      					case "26.0"  : PS_Status1txt.postUpdate ("Ausfall Fühler Solarvorlauf")
      					case "27.0"  : PS_Status1txt.postUpdate ("Ausfall Fühler Außentemperatur")
      					case "34.0"  : PS_Status1txt.postUpdate ("Überhitzung Speicher 1")
      					case "35.0"  : PS_Status1txt.postUpdate ("Überhitzung Speicher 2")
      					case "49.0"  : PS_Status1txt.postUpdate ("Solarstation unterkühlt")
      					case "50.0"  : PS_Status1txt.postUpdate ("Kollektor eingefroren")
      					default : PS_Status1txt.postUpdate (wert.toString)
      					}
      					
      end
      
      J 1 Reply Last reply Reply Quote 0
      • J
        Ju5t1n @glitzi last edited by

        @glitzi
        Hallo,
        ist der Bus bei der Paradigma Solaranlage der gleich wie der bei der Pelletsheizung (ParaDigma II)?
        Wie liest du den aus?

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

          @Ju5t1n
          Hallo,

          kann ich nicht genau sagen, aber vermutlich schon.

          Ich habe mir das laut der Seite hier gebastelt und kann so nun die Werte Seriell abfragen.

          Seite mit Bauanleitung: https://ringwelt.de/homeautomation/heizungsanlage/systa-aqua-ii-logger/124-systa-aqua-ii-logger.html

          Leider geht beim reinen mitlesen nur die Solaranlage, meinen Speicher kann ich nicht auslesen.

          MfG

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

            Ohne es mir genau anzuschauen, würde ich das wie folgt angehen:
            Die Library serialport nutzen und die Daten mit einem Parser (entweder vorgefertigt oder selbst implementiert) weiterreichen:
            https://serialport.io/docs/api-parsers-overview

            Dann musst du nur noch auf die fertig umgewandelten Datenpakete reagieren.

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

              @AlCalzone

              Stecke jetzt schon ewig fest...

              Den String der später von der seriellen Schnittstelle kommt habe ich erstmal zum Testen so reinkopiert.

              Das finden der Startsequenz habe ich irgendwie hinbekommen... (Optimierung notwendig?)

              Jetzt kommts...

              Der String muss gesplittet, von HEX in INT gewandelt und dann HIGH und LOW Byte tauschen werden.

              createState('Paradigma_String');
              createState('Paradigma_Kollektor');
              
              // Test-String bevor ich die serielle Anbindung realisiere
              var text = "0000000 fc 3e 24 01 09 02 87 02 43 01 49 00 00 00 56 01 00 00 00 00 00 00 00 00 00 00 10 10 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 09 02 00 00 00 00 00 00 00 00 00 00 00 00 85 fc 3e 24 01 09 02 87 02 43 01 4a 00 00 00 57 01 00 00 00 00 00 00 00 00 00 00 10 10 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 09 02 00 00 00 00 00 00 00 00 00 00 00 00 83 23 03 d0 00 09 01 fc 3e 24 01 09 02 87 02 43 01 4a 00 00 00 57 01 00 00 00 00 00 00 00 00 00 00 10 10 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 08 02 00 00 00 00 00 00 00 00 00 00 00 00 84 fc 3e 24 01 08 02 87 02 43 01 49 00 00 00 57 01 00 00 00 00 00 00 00 00 00 00 10 10 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 09 02 00 00 00 00 00 00 00 00 00 00 00 00 85 23 03 d0 00 08 02 fd 05 aa 24 01 02 04 29 fc 3e 24 01 08 02 87 02 43 01 49 00 00 00 57 01 00 00 00 00 00 00 00 00 00 00 10 10 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 09 02 00 00 00 00 00 00 00 00 00 00 00 00 85 fc 3e 24 01 09 02 87 02 43 01 4a 00 00 00 58 01 00 00 00 00 00 00 00 00 00 00 10 11 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 09 02 00 00 00 00 00 00 00 00 00 00 00 00 81 23 03 d0 00 09 01 fc 3e 24 01 0a 02 87 02 43 01 49 00 00 00 58 01 00 00 00 00 00 00 00 00 00 00 10 11 0c 0b 14 05 00 00 00 00 00 05 44 00 00 00 00 00 00 00 00 00 00 00 0a 02 00 00 00 00 00 00 00 00 00 00 00 00 80 fc 1f 0b 01 02 0a 01 58 02 87 00 00 00 00 00 00 00 00 10 11 0c 0b 00 00 00 00 00 00 00 00 44"
              // ca. 52 Grad auf Position 4 und 5 nach dem match
              var match = "fc 3e 24 01"
               
              var buffer
              var wert
              var position
               
                  position = text.indexOf(match);
                  if (position == 0) 
                  {}
                  else
                  {
                  text = text.substring(position);
                  setState('Paradigma_String', text, true);
                  }
              
              // AB HIER BEKOMME ICH ES NICHT MEHR GEREGELT
              
              
              
              function()
              {
               
              var request= require('request');
              request.post(text, function(error, response, body){
                if (body) {
                    
                    var parts_Paradigma = body.split('\n')[0];
                      
              //
              //Hier muss gerechnet werden
              //
              //parts[5] (ist in HEX) *256 + parts[4] (ist in HEX) -> int /10
              //      
              //      setState('Paradigma_Kollektor',wert, true);
              //
                }
               
              }); 
               
              }
              )
              
              
              AlCalzone 1 Reply Last reply Reply Quote 0
              • AlCalzone
                AlCalzone Developer @glitzi last edited by AlCalzone

                @glitzi Mit binären Daten kannst du mit Buffern sehr schön arbeiten, da sie dir das lästige Rechnen und so abnehmen - dazu musst du aber aus text alle Leerzeichen entfernen.
                Und die erste 0 scheint auch überzählig, wie kommst du denn an die Daten? Greifst du nicht direkt auf die Schnittstelle zu? Mir scheint es, als wäre der delimiter-parser für deine Zwecke super geeignet:

                const SerialPort = require('serialport')
                const Delimiter = require('@serialport/parser-delimiter')
                const port = new SerialPort('/dev/tty-usbserial1')
                
                const parser = port.pipe(new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") }))
                parser.on('data', chunk => {
                	// Wird für jeden Abschnitt der Nutzdaten aufgerufen, d.h. beim ersten Aufruf wäre es ein Buffer mit Inhalt
                	// 0902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085
                
                	// High und low byte tauschen (wirklich nötig??)
                	chunk = chunk.swap16();
                
                	// Auf Daten zugreifen (die 4 bytes Startsequenz sind hier nicht enthalten)
                	let val = chunk[1] * 256 + chunk[0] / 10;
                	// Das /10 kommt mir spanisch vor, alternativ kannst du auch direkt mehrbytige
                	// Zahlen aus dem Buffer lesen
                	val = chunk.readUInt16BE(0) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                	val = chunk.readUInt16LE(0) // liest eine 2-byte-Zahl ab Position 0 und tauscht Bytes
                });
                

                Wenn du die Daten nicht direkt vom Serialport bekommst, kannst du trotzdem den Parser nutzen:

                const Delimiter = require('@serialport/parser-delimiter')
                const Passthrough = require('stream').PassThrough;
                
                const myStream = new Passthrough();
                const parser = myStream.pipe(new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") }))
                
                parser.on('data', chunk => {
                	// wie vorher
                });
                
                // Bei jedem Dateneingang:
                myStream.push(hexDatenOhneLeerzeichen, "hex");
                

                Denk aber dran, @serialport/parser-delimiter und ggf. serialport in den Adaptereinstellungen als zusätzliche Module zu laden.

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

                  @AlCalzone

                  Das sieht super aus, obwohl ich das erstmal verdauen muss 😉

                  die /10 kommen wegen der Kommastellen, nach Umrechnung 520 > auf 52,0

                  Die Daten werden nach dem Wechsel von OpenHAB auf IOBroker direkt von Serial Port kommen. In der Übergangsphase muss ich erstmal alle Daten, Schnittstellen, Influx, VIS usw. vorbereiten.

                  Daher noch eine Frage:
                  Wo könnte ich den Test-Datensatz z.B. "0000000 fc 3e 24 01 09 02 87 02 43 01 49 00 00 00 56 01 00 00 00 00 00 00 usw." einfügen?

                  const myStream = new Passthrough(HIER?);

                  MfG

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

                    @glitzi sagte in Daten Seriell von Paradigma Solaranlage lesen:

                    die /10 kommen wegen der Kommastellen, nach Umrechnung 520 > auf 52,0

                    Dann musst du aber erst addieren und dann teilen, nicht nur das eine Byte. Also

                    chunk.readUInt16LE(0) / 10
                    

                    @glitzi sagte in Daten Seriell von Paradigma Solaranlage lesen:

                    Wo könnte ich den Test-Datensatz z.B. "0000000 fc 3e 24 01 09 02 87 02 43 01 49 00 00 00 56 01 00 00 00 00 00 00 usw." einfügen?

                    Vor Zeile 12:

                    const hexDatenOhneLeerzeichen = "fc3e240109...";
                    

                    Führende Nullen am besten weglassen, sonst wird versucht, daraus was zu lesen. Und wie gesagt ohne Leerzeichen

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

                      @AlCalzone

                      jetzt kämpfe ich noch mit folgender Fehlermeldung:

                      const Delimiter = require('@serialport/parser-delimiter')
                      const Passthrough = require('stream').PassThrough;
                      createState('Paradigma_Kollektor');
                       
                      const myStream = new Passthrough();
                      const parser = myStream.pipe(new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") }))
                       
                      parser.on('data', chunk => {
                      	val = chunk.readUInt16BE(0) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                          setState('Paradigma_Kollektor', text, true);
                      });
                       
                      // Bei jedem Dateneingang:
                      const hexDatenOhneLeerzeichen = "fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                      myStream.push(hexDatenOhneLeerzeichen, "hex");
                      
                      
                      
                      19:08:50.225	error	javascript.0 (11358) script.js.Paradigma_Test: Error: Cannot find module '/opt/iobroker/node_modules/iobroker.javascript/lib/../../stream'
                      19:08:50.227	error	javascript.0 (11358) at script.js.Paradigma_Test:2:21
                      19:08:50.233	error	javascript.0 (11358) script.js.Paradigma_Test: script.js.Paradigma_Test:2
                      19:08:50.234	error	javascript.0 (11358) at script.js.Paradigma_Test:2:38
                      

                      Die Module habe ich eingebunden.
                      46cac506-97d1-4b2c-aefe-9b2ecd366b39-image.png

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

                        @glitzi Komisch, "stream" ist ein eingebautes Modul von Node.js - das müsste er finden (aber nicht da wo es gesucht wird).

                        Alternativ (ungetestet) lass mal Zeilen 2 und 5 weg, ändere 6 zu

                        const parser = new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") });
                        

                        und ersetze myStream in Zeile 15 durch parser

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

                          @AlCalzone
                          Einfach KLASSE es funktioniert...

                          Noch eine Frage:

                          Ist es egal wenn folgende Zeilen erst am Ende stehen?

                          // Bei jedem Dateneingang:
                          const hexDatenOhneLeerzeichen = "fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                          myStream.push(hexDatenOhneLeerzeichen, "hex");
                           
                           
                          
                          AlCalzone G 2 Replies Last reply Reply Quote 0
                          • AlCalzone
                            AlCalzone Developer @glitzi last edited by

                            @glitzi Wichtig ist dass das .push nach dem .on("data") steht. Und die Definition der Daten muss vor dem push bekannt sein.

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

                              @AlCalzone

                              Wenn ich Testweise einige Zeichen vor das fc3... einfüge sollte das Skript ja trotzdem erst bei fc3 etc Anfangen.

                              Leider macht er das nicht?

                              const parser = new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") });
                               
                              parser.on('data', chunk => {
                              	val = chunk.readUInt16LE(4) // liest eine 2-byte-Zahl ab Position 0 ohne Bytes zu tauschen
                                  setState('Paradigma_Kollektor', val /10, true);
                              

                              @AlCalzone
                              Einfach KLASSE es funktioniert...

                              Noch eine Frage:

                              Ist es egal wenn folgende Zeilen erst am Ende stehen?

                              // Bei jedem Dateneingang:
                              const hexDatenOhneLeerzeichen = "fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                              Parser.push(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:

                                Wenn ich Testweise einige Zeichen vor das fc3... einfüge sollte das Skript ja trotzdem erst bei fc3 etc Anfangen.
                                Leider macht er das nicht?

                                Nein, der teilt die eingehenden Daten an fc3e2401 auf. D.h. alles was vorher kommt, wird auch an die verarbeitende Methode gegeben.
                                Du könntest z.B. bevor du die Daten auswertest prüfen, ob die erhaltene Datenmenge dem entspricht, was zu erwarten ist, z.B.:

                                if (chunk.length < 10) return;
                                

                                (ich weiß nicht wie viele Bytes Nutzdaten üblicherweise kommen, ggf. muss die Schwelle kleiner oder größer gewählt werden.)

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

                                  @AlCalzone
                                  Da kommen auch noch sehr viele andere (und unbekannte) Daten über die Schnittstelle rein, daher benötige ich x Byte nach dem fc3e2401 und nur diese sollen dann verarbeitet werden.

                                  Eventuell versteh ich das auch falsch?
                                  aktuell nutze ich ja nur einen Test Datensatz, später kommt das ja von der Seriellen Schnittstelle

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

                                    @glitzi Hmm, scheint so als würde der Parser genau anders herum arbeiten als du das brauchst. Er wartet immer bis die Byte-Folge kommt und gibt alles davor aus.
                                    Ich hab so einen ähnlichen Anwendungsfall in meinem Adapter, ich bau dir mal ne Alternative.

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

                                      @glitzi schau mal hier. Ab Zeile 56 steht wie du es nutzen kannst. Zeile 63 bitte mit deiner bestehenden Auswertung ersetzen, ich hab das nur zum Testen mal geloggt. Außerdem war noch ein kleiner Fehler drin (letzte Zeile). Die Daten müssen per write in den Parser geschrieben werden, nicht per push.

                                      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
                                      	10, // Wie viele Bytes nach dem Start ausgewertet werden
                                      );
                                      parser.on("data", (chunk) => {
                                      	console.log(chunk.toString("hex"));
                                      });
                                      
                                      // Bei jedem Dateneingang:
                                      
                                      const hexDatenOhneLeerzeichen =
                                      	"00112233fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                                      
                                      parser.write(hexDatenOhneLeerzeichen, "hex");
                                      

                                      Eine Testausgabe auf der Konsole zeigt die gewünschten 10 Bytes nach den Anfangs-Bytes.:

                                      $ node preambleParser.js
                                      09028702430149000000
                                      0902870243014a000000
                                      
                                      G 2 Replies Last reply Reply Quote 0
                                      • G
                                        glitzi @AlCalzone last edited by glitzi

                                        Ich bin Stolz auf mich 😉

                                        so geht es

                                        
                                        const parser = new Ready({ delimiter: Buffer.from("fc3e2401", "hex") });
                                        

                                        und

                                        parser.write(hexDatenOhneLeerzeichen, "hex");
                                        

                                        Nächste Woche benötige ich dann dieses Skript und muß das Empfangene dann in die obere Zeile bringen?

                                        const SerialPort = require('serialport')
                                        const Delimiter = require('@serialport/parser-delimiter')
                                        const port = new SerialPort('/dev/tty-usbserial1')
                                         
                                        const parser = port.pipe(new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") }))
                                        parser.on('data', chunk => {
                                        	
                                        	chunk = chunk.swap16();
                                         
                                        });
                                        

                                        Der Vollständigkeit nochmal das ganze...

                                        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 parser = new Delimiter({ delimiter: Buffer.from("fc3e2401", "hex") });
                                        
                                        //const parser = new PreambleParser(Buffer.from("fc3e2401", "hex"), 10, );
                                        
                                        const parser = new Ready({ delimiter: Buffer.from("fc3e2401", "hex") });
                                        
                                        parser.on('data', chunk => {
                                        
                                            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 /10, 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 /10, 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);
                                        }
                                        
                                        });
                                        
                                        // Bei jedem Dateneingang:
                                        //const hexDatenOhneLeerzeichen = "fc3e24010902870243014900000056010000000000000000000010100c0b1405000000000005440000000000000000000000090200000000000000000000000085fc3e24010902870243014a00000057010000";
                                        const hexDatenOhneLeerzeichen = "fc3e240163007002d300f8ff000072010000000000010001100015141b0b1439000000000039440000000000000000000000630000000000000000000000000001fc3e240163007002d300f9ff0000";
                                        //parser.push(hexDatenOhneLeerzeichen, "hex");
                                        parser.write(hexDatenOhneLeerzeichen, "hex");
                                        
                                        AlCalzone G 2 Replies Last reply Reply Quote 0
                                        • AlCalzone
                                          AlCalzone Developer @glitzi last edited by

                                          @glitzi Ich fürchte mit dem Ready-Parser wird es auch nicht hinhauen. Wenn du da mal das Beispiel liest:

                                          all data after READY is received

                                          d.h. du bekommst nur einmal sämtliche Daten, die nach dem allerersten fc3e2401 kommen. Allerdings enthält schon dein Beispielcode zwei "Datenpakete". Mit meinem PreambleParser bekommst du die angegebene Anzahl an Bytes nach jedem fc3e2401 - nach deinem Code zu urteilen brauchst du 34 Bytes.

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

                                            @AlCalzone

                                            Kann das nicht funktionieren wenn ich alle x Sekunden die Daten von der Schnittstelle in einen Datenpunkt schreibe und den Parser damit neu triggere?

                                            Dann sollte ja auch das überlange Telegramm nicht stören.

                                            Dazu wäre noch interessant wie ich das vorher von der Schnittstelle in einen Datenpunkt bekomme?

                                            AlCalzone 1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            946
                                            Online

                                            31.9k
                                            Users

                                            80.1k
                                            Topics

                                            1.3m
                                            Posts

                                            communication heating javascript
                                            3
                                            53
                                            4373
                                            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