Js wie in "Puffer" schreiben

[sveni_lee]

ich möchte gern ankommendende Daten so lange in eine Puffer schreiben bis ein bestimmtes Zeichen am ende kommt und dann erst die "kompletten Daten" übergeben.

folgendes:

hier wird auf ankommende Daten reagiert:

	on('data', function (data) {

		var iscp_message = eiscp_packet_extract(data),
			result = iscp_to_command(iscp_message);

		result.iscp_command = iscp_message;
        result.host  = config.host;
        result.port  = config.port;
        result.model = config.model;

		self.emit('debug', util.format("DEBUG (received_data) Received data from %s:%s - %j", config.host, config.port, result));
		self.emit('data', result);

		// If the command is supported we emit it as well
		if (typeof result.command !== 'undefined') {
			if (Array.isArray(result.command)) {
				result.command.forEach(function (cmd) {
					self.emit(cmd, result.argument);
				});
			} else {
				self.emit(result.command, result.argument);
			}
		}
	});

und hier werden die Daten entpacket:

function eiscp_packet_extract(packet) {
    /*
      Exracts message from eISCP packet
      Strip first 18 bytes and last 3 since that's only the header and end characters
    */
    return packet.toString('ascii', 18, packet.length - 3);
}

ich möchte die ankommenden Daten nun solange in einen Puffer schreiben (zusammenfügen) bis ein bestimmten Zeichen am Ende der Daten kommt.

in HEX: 0a

in Ascii: "." (Punkt)

erst danach soll das komplette Paket übergeben werden…

Bsp.:

in HEX

~~https://i.imgur.com/dcdD8fc.jpg" />

umgewandelt:

~~https://i.imgur.com/bVshqAe.jpg" />

wie könnte man das realisieren?~~~~

[paul53]

@sveni_lee:

in HEX: 0a

in Ascii: "." (Punkt) `
HEX: 0a = LF(line feed)

ASCII: "\n" (new line)

[Jey Cee]

Du musst mit Streams Arbeiten. Schau dir mal "pipe" an. Damit geht sowas.

Gesendet von meinem m8 mit Tapatalk

[sveni_lee]

@paul53:

HEX: 0a = LF(line feed)

ASCII: "\n" (new line) `

Ich verste nicht so ganz was du mir damit sagen möchtest… ??? :?:

@Jey Cee:

Du musst mit Streams Arbeiten. Schau dir mal "pipe" an. Damit geht sowas. `

Ich hab mir mal einiges bei stackoverflow durgelesen aber so richtig schlau werde ich daraus noch nicht…

const bl = require('bl')
, fs = require('fs')

fs.createReadStream('README.md')   
   .pipe(bl(function (err, data) { //  note 'new' isn't strictly required
      // `data` is a complete Buffer object containing the full data
      console.log(data.toString())   
}))

[paul53]

@sveni_lee:

Ich verste nicht so ganz was du mir damit sagen möchtest… ??? `
https://www.torsten-horn.de/techdocs/ascii.htm.

"." (Punkt) hat den hexadezimalen Wert 0x2e.

[sveni_lee]

jetzt verste ich was du meinst,

0a am ende steht für LF(line feed) und nicht für den Punkt… okay verstanden.

mein Problem ist das ein Antwort in mehreren Paketen gesendet wird und das ende immer "0A"...

Ich möchte nun die Pakete "zusammensetzen" im Moment werden sie leider als einzelne Teile verarbeitet...

[paul53]

Wenn es Strings sind, kann man diese einfach verketten (anhängen). Ob das LF enthalten ist, kann man testen.

if(str.indexOf('\n') != -1) { // LF ist enthalten
   ...
}

Das sollte Dir die ASCII-Anmerkung sagen.

[sveni_lee]

okay, aber dann müsste ich doch die strings so lange in einen Puffer schreiben bis ein LF zeichen kommt, richtig?

oder verstehe ich an der stelle etwas falsch?

[paul53]

@sveni_lee:

okay, aber dann müsste ich doch die strings so lange in einen Puffer schreiben bis ein LF zeichen kommt, richtig? `
So würde ich es versuchen.

[sveni_lee]

und dann kommen wir zu meiner ursprünlichen Frage…

wie kann ich in einen Puffer schreiben?

[paul53]

Wenn es sich tatsächlich um Strings handelt, dann ist der Puffer ein String, der als Leerstring initialisiert wird, und an den man die Stringbruchstücke solange anhängt, bis ein LF enthalten ist. Der Hex-Dump zeigt allerdings etliche Steuerzeichen innerhalb der Daten.

[sveni_lee]

die Antworten die ich erwarte sehen dann so aus…

NRI<response status="ok"><device id="TX-NR525"><brand>ONKYO</brand><category>AV Receiver</category><year>2013</year><model>TX-NR525</model><destination>xx</destination><firmwareversion>1060-9110-0000-</firmwareversion></device></response>

[paul53]

@sveni_lee:

die Antworten die ich erwarte sehen dann so aus… `
Das ist unvollständiger XML-Code.

NRI
 <response status="ok"><device id="TX-NR525"><brand>ONKYO</brand>
		<category>AV Receiver</category>
		<year>2013</year>
		<model>TX-NR525</model>
		<destination>xx</destination>
		<firmwareversion>1060-9110-0000-</firmwareversion></device></response> 

[sveni_lee]

richtig… das Problem ist das der xml code in teilen gesendet wird und nicht vollständig übergeben wird...

~~https://i.imgur.com/LFkxKiN.jpg" />

~~https://i.imgur.com/qLyVEPv.jpg" />

der komplette xml-code setzt sich den Paketen 920,921,922,923 und 924 zusammen…

darum möchte ich die enzelnen Teile wieder zusammensetzen um den kompletten und brauchbaren xml code zu bekommen...~~~~

[paul53]

Das Packet 920 enthält einen Header, der mit "!1NRI" endet. Haben die anderen Packete auch diesen Header ? Der müsste dann erst ausgefiltert werden, bevor man die XML-Teile verkettet.

Wie sieht das letzte Packet aus ?

[sveni_lee]

nein, die anderen haben diesen header nicht… der isr aber wichtig für die weiterverarbeitung müsste also am Anfang des Paketes bestehen bleiben...

~~https://i.imgur.com/sTO0PT2.jpg" />

~~https://i.imgur.com/jryLouz.jpg" />

~~https://i.imgur.com/E80eKKM.jpg" />

https://i.imgur.com/YKPAKSY.jpg" />~~~~~~

[paul53]

Sind das keine Header bis zum Byte 0x41 : "|" (senkrechter Strich) ? Müssten die nicht rausgefiltert werden ?

Wo erscheint das LF ?

[sveni_lee]

das ist richtig…

~~https://i.imgur.com/SaV0DU6.jpg" />

Wireshark sagt mir das der "Datenteil" immer erst mit byte 66 startet…

https://i.imgur.com/wzzsRhF.jpg" />~~

[paul53]

Werden die ersten 66 Zeichen auch an die Funktion übergeben ?

on('data', function (data) {

Oder sind sie an der Stelle schon ausgefiltert ?

[AlCalzone]

Ich gehe nicht davon aus, dass du die TCP-Header ebenfalls empfängst. Wireshark zeigt dir das gesamte Datenpaket an, das übers Netzwerk geht, Anwendungen sehen i.d.R. nur den Inhalt des TCP-Pakets (in deinem Fall vermutlich ab Byte 66).