Neuer ioBroker-Blog online: Monatsrückblick März/April 2026

[AlCalzone]

@glitzi Auch nicht bevor du das Skript startest?

[glitzi]

@AlCalzone

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

[AlCalzone]

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

[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]

@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.

[glitzi]

@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]

@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");

[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();
});

[MatthiasROW]

Hallo, leider ist die Seite mit der Bauanleitung nicht mehr verfügbar. Gibt es die noch irgendwo?

[Samson71]

@MatthiasROW
Unabhängig davon, dass dieser Beitrag mit über 5 Jahren mehr als steinalt ist........

Schonmal auf der genannten Webseite selber nachgesehen? Nur weil ein (uralter) Link nicht mehr passt, existiert die Webseite und auch deren Inhalte grundsätzlich noch.
Ich finde da jedenfalls ne Menge Infos zum Systa Aqua II - Logger incl. der Schaltungsbeschreibung.