Verwendung des SerialPort-Moduls in Node.js

Zweck

Serielle Schnittstellen werden häufig für die Kommunikation zwischen dem Host-Computer und verschiedenen Schaltungsmodulen verwendet. Mit dem Modul SerialPort kann die serielle Schnittstelle in Node.js bedient werden. In diesem Artikel wird die Verwendung kurz erläutert.

Offizielle Website: https://serialport.io/
Dokumentation: https://serialport.io/docs/
Projektadresse: https://github.com/serialport/node-serialport

Die aktuelle SerialPort-Modulversion ist 9.2.7

Modulinstallation

Verwenden Sie den folgenden Befehl, um das SerialPort-Modul zu installieren:

npm installiere seriellen Port

Einige der SerialPort-Modulfunktionen sind in C/C++ implementiert, daher sind für die Ausführung auf verschiedenen Plattformen Binärdateien erforderlich, die für die jeweilige Plattform verfügbar sind. Für gängige Plattformen gibt es normalerweise vorkompilierte Binärdateien. Wenn nicht, versuchen Sie normalerweise, es mit node-gyp zu kompilieren (das von Python 3.x abhängt). Normalerweise kümmert sich der Paketmanager automatisch um die relevanten Angelegenheiten:

Manchmal oder auf manchen Plattformen kann eine manuelle Kompilierung erforderlich sein. Für die Kompilierung sind entsprechende Kompilierungstools auf der Plattform erforderlich. Weitere Informationen finden Sie im Kapitel zur Modulkompilierung im Artikel „Erste Schritte mit Node.js 02: Paketmanager npm“.

Nach der Installation des Kompilierungstools können Sie das SerialPort-Modul neu installieren oder manuell kompilieren. Weitere Informationen finden Sie im Abschnitt „Installieren von SerialPort“ in der Dokumentation des SerialPort-Moduls: https://serialport.io/docs/guide-installation/

Grundlegende Verwendung

Nach der Installation des SerialPort-Moduls können Sie es mit const SerialPort = require('serialport') importieren.

Scan-Ports

Verwenden Sie SerialPort.list(): Promise<PortInfo[]> um die Liste der seriellen Ports auf dem Gerät abzurufen, wie in der folgenden Demonstration:

const SerialPort = erfordern('serialport');

SerialPort.list().then((ports) => {
    console.log(ports); // Liste der seriellen Ports drucken }).catch((err) => {
    console.log(fehler);
});

Es ist zu beachten, dass der gleiche Port in dieser Liste mehrfach auftauchen kann.

Sie können die obige Methode auch mit async / await verwenden:

const SerialPort = erfordern('serialport');

(asynchron () => {
    versuchen {
        lass ports = warte auf SerialPort.list();
        console.log(Ports); // Serielle Portliste drucken } catch (Fehler) {
        konsole.log(Fehler);
    }
})();

Offene Ports

Standardmäßig wird beim Erstellen eines SerialPort-Objekts der Port geöffnet, beispielsweise wie folgt:

const SerialPort = erfordern('serialport');

const port = neuer SerialPort('COM6', (err) => {
    wenn (Fehler) {
        console.log('Portöffnung fehlgeschlagen!');
        zurückkehren;
    }
    console.log('Port erfolgreich geöffnet!');
});

Der Konstruktor der SerialPort-Klasse verfügt über eine Option autoOpen, die steuert, ob der Port beim Erstellen des Objekts automatisch geöffnet wird. Standardmäßig wird der Port automatisch geöffnet, Sie können diese Option jedoch auch deaktivieren, sodass Sie den Port später manuell öffnen können:

const SerialPort = erfordern('serialport');

const port = neuer SerialPort('COM6', { autoOpen: false });

port.open(Funktion (Fehler) {
    wenn (Fehler) {
        console.log('Portöffnung fehlgeschlagen!');
        zurückkehren;
    }
    console.log('Port erfolgreich geöffnet!');
});

Im Konstruktor der Klasse SerialPort können Sie mit der Option baudRate die Baudrate für die Kommunikation über den seriellen Port festlegen. Der Standardwert ist 9600:

const SerialPort = erfordern('serialport');

const port = new SerialPort('COM6', { baudRate: 115200 }); // Baudrate auf 115200 einstellen

Weitere Informationen finden Sie im folgenden Abschnitt zur Konstruktionsmethode der SerialPort-Klasse.

Senden von Daten

Zum Senden von Daten können Sie die write des SerialPort-Objekts verwenden. Diese Methode legt die zu sendenden Daten in den Sendepuffer und sendet sie dann der Reihe nach, beispielsweise wie folgt:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

port.write('Hallo Welt!\n'); // String senden port.write(Buffer.from('Hey!\n')); // Pufferdaten senden port.write(new Uint8Array([0x48, 0x69, 0x21, 0x0A])); // Byte-Array senden 

Der write kann auch eine Rückruffunktion hinzugefügt werden:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

port.write('Hallo Welt!\n', (err) => {
    wenn (Fehler) {
        console.log('Schreibvorgang fehlgeschlagen!');
        zurückkehren;
    }
    console.log('Schreibvorgang erfolgreich!');
});

Es ist zu beachten, dass, wenn die obige Rückruffunktion in einem nicht abnormalen Zustand ausgelöst wird, dies nur bedeutet, dass die write selbst den Vorgang abgeschlossen hat, und nicht, dass die Daten vollständig vom Port gesendet wurden. Sie können die drain -Methode verwenden, um damit umzugehen. Diese Methode wird blockiert, bis das Senden abgeschlossen ist:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

port.write('Hallo Welt!\n');
port.drain(err => {
    wenn (Fehler) zurückgeben;
    console.log('Senden abgeschlossen!');
});

Empfangen von Daten

Zum Empfangen von Daten stehen Ihnen folgende Methoden zur Verfügung:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

// Im Pausenmodus auf empfangene Daten hören und Daten aktiv lesen port.on('readable', () => {
    console.log(port.read()); // Verwenden Sie die Lesemethode zum Lesen von Daten, Sie können die Anzahl der zu lesenden Bytes angeben});

// Empfangene Daten im fließenden Modus abhören port.on('data', (data) => {
    konsole.log(Daten);
});

Zusätzlich zu den oben genannten Methoden können Sie auch pipe verwenden, um Daten in einen anderen Stream zu übertragen.

Fehlerbehandlung

Die meisten Operationen des SerialPort-Objekts haben Rückruffunktionen und der erste Parameter in der Rückruffunktion ist das Ausnahmeobjekt. Darüber hinaus können Sie das Fehlerereignis auch für die einheitliche Behandlung von Ausnahmen verwenden:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

port.on('Fehler', err => {
    console.log(fehler);
});

Datenparser

Das SerialPort-Modul hat einige Datenparser vorbereitet, die hauptsächlich zur Verarbeitung einiger gängiger Formen empfangener serieller Portdaten verwendet werden. Die bereitgestellten Hauptfunktionen sind wie folgt:

ByteLength-Parser
Parsen basierend auf der Länge der empfangenen Daten:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

const ByteLength = require('@serialport/parser-byte-length');
const parser = port.pipe(new ByteLength({ length: 8 })); // Trigger parser.on('data', chunk => {
    console.log(chunk); // Empfangene Daten drucken });

ccTalk-Parser
Analysieren Sie Daten im ccTalk-Format, siehe: https://en.wikipedia.org/wiki/CcTalk

Trennzeichenparser
Verarbeiten Sie Daten mit angegebenen Zeichen als Grenzen:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

const Delimiter = require('@serialport/parser-delimiter');
const parser = port.pipe(new Delimiter({ delimiter: '\n' })); // Daten durch \n getrennt verarbeiten parser.on('data', chunk => {
    console.log(chunk.toString()); // Empfangene Daten drucken });

Die Trennzeichenoption kann Zeichenfolge|Puffer|Zahl[] sein. Die Option „includeDelimiter“ gibt an, ob das Trennzeichen in den Daten enthalten ist. Standardmäßig ist dies nicht der Fall.

InterByteTimeout-Parser
Wenn innerhalb der angegebenen Zeit keine Daten empfangen werden, wird eine Analyse ausgelöst:

const SerialPort = erfordern('serialport');
const port = neuer SerialPort('COM6');

const InterByteTimeout = erfordern('@serialport/parser-inter-byte-timeout');
const parser = port.pipe(new InterByteTimeout({interval: 2000})); // 2000 Millisekunden ohne Datenempfang lösen parser.on('data', chunk => { aus.
    console.log(chunk); // Empfangene Daten drucken });

Mit der Option maxBufferSize legen Sie fest, dass nach dem Empfang dieser Datenmenge eine Aktion ausgelöst wird, auch wenn kein Timeout vorliegt.

Readline-Parser
Analysieren Sie Daten in Zeilen. Der Standardzeilentrenner ist \n . Sie können die Trennzeichenoption verwenden, um ihn auf einen anderen Wert zurückzusetzen, z. B. \r\n .

Bereit Parser
Das Parsen beginnt mit einer Flagge.

Regex-Parser
Analysieren Sie mit regulären Ausdrücken als Trennzeichen.

SerialPort-Klasse

Die Hauptanwendung des SerialPort-Moduls besteht in der Verwendung der SerialPort-Klasse, die im Kapitel „Stream-Schnittstelle“ der SerialPort-Moduldokumentation vorgestellt wird: https://serialport.io/docs/api-stream. Hier ist ein kurzer Auszug einiger Inhalte.

Konstruktionsmethode

new SerialPort(path [, openOptions] [, openCallback])

Der Konstruktor wird zum Erstellen eines seriellen Portobjekts verwendet, Pfad ist die serielle Portnummer und openCallback ist die Rückruffunktion, wenn das automatische Öffnen fehlschlägt.

Allgemeine Optionen von openOptions sind wie folgt:

Eigentum

SerialPort verfügt über die folgenden zu lesenden Eigenschaften:
path , baudRate , isOpen , binding

Ereignis

Die von SerialPort ausgelösten Ereignisse sind die folgenden:

• Wird ausgelöst, wenn der open Port geöffnet wird;
• error wird ausgelöst, wenn ein Fehler gesendet wird;
• close Wird ausgelöst, wenn der Port geschlossen wird;
• data werden ausgelöst, wenn Daten empfangen werden;
• drain Wenn die Schreibmethode „false“ zurückgibt, wird das Ereignis ausgelöst, wenn die Schreibmethode erneut aufgerufen wird.

Verfahren

Einige der mit SerialPort verfügbaren Methoden sind folgende:

• open(() => {}): void öffnet den Port;
• update(options: updateOptions, callback?: err => {}): void Baudrate ändern;
• write(data: string|Buffer|Array<number>, encoding?: string, callback?: error => {}): boolean sendet Daten;
• read(size?: number): string|Buffer|null lesen;
• close(callback?: error => {}): void schließt den Port;
• set(options: setOptions, callback?: error => {}): void Flusssteuerung festlegen;
• get(callback: (error, data: ModemStatus) => {}): void Ruft den Flusssteuerungsstatus des geöffneten Ports ab;
• flush(callback? error => {}):void Löscht die unverarbeiteten Daten in den Empfangs- und Sendepuffern.
• drain(callback? error => {}):void , bis die Daten gesendet wurden;
• pause(): this pausiert den fließenden Modus, löst das Datenereignis aus und wechselt in den pausierten Modus;
• resume(): this setzt das Datenereignis fort und wechselt vom Pausenmodus in den fließenden Modus;

Befehlszeilentools

Das SerialPort-Modul bietet auch einige Befehlszeilentools zur direkten Verwendung in der Befehlszeilenschnittstelle. Nachfolgend finden Sie eine Demonstration der Verwendung der Homepage der offiziellen Website:

Weitere Informationen finden Sie im Abschnitt „Befehlszeilentools“ in der Dokumentation des SerialPort-Moduls: https://serialport.io/docs/guide-cli

Zusammenfassen

Die Hauptverwendung des SerialPort-Moduls von Node.js ist der obige Inhalt.

Ein weiterer erwähnenswerter Punkt ist, dass das SerialPort-Modul den seriellen Port nicht direkt bedient, sondern die zugrunde liegende Schnittstelle auf jeder Plattform aufruft, um den seriellen Port zu verwenden. Wenn Sie verwandte Inhalte entwickeln oder besondere Anforderungen haben, können Sie auf die bindungsbezogenen Inhalte im Dokument zum SerialPort-Modul verweisen.

Dies ist das Ende dieses Artikels über die Verwendung des SerialPort-Moduls (Serieller Port) in Node.js. Weitere relevante Inhalte zu Node.js SerialPort finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!