Use of SerialPort module in Node.js

Purpose

Serial ports are often used for communication between the host computer and various circuit modules. The SerialPort module can be used to operate the serial port in Node.js. This article will briefly explain its use.

Official website: https://serialport.io/
Documentation: https://serialport.io/docs/
Project address: https://github.com/serialport/node-serialport

The current SerialPort module version is 9.2.7

Module Installation

Use the following command to install the SerialPort module:

npm install serialport

Some of the SerialPort module functions are implemented in C/C++, so different platforms require binary files available for that platform to run. For common platforms, there are usually pre-compiled binary files. If not, you will usually try to compile it using node-gyp (which depends on Python 3.x). Usually the package manager will automatically handle the relevant matters:

Sometimes or on some platforms manual compilation may be required. For compilation, corresponding compilation tools are required on the platform. You can refer to the module compilation chapter in the article "Getting Started with Node.js 02: Package Manager npm".

After installing the compilation tool, you can reinstall the SerialPort module or compile it manually. For details, please refer to the Installing SerialPort section in the SerialPort module documentation: https://serialport.io/docs/guide-installation/

Basic use

After installing the SerialPort module, you can import it using const SerialPort = require('serialport') .

Scan ports

Use SerialPort.list(): Promise<PortInfo[]> static method to get the serial port list on the device, such as the following demonstration:

const SerialPort = require('serialport');

SerialPort.list().then((ports) => {
    console.log(ports); // Print serial port list }).catch((err) => {
    console.log(err);
});

It should be noted that the same port may appear repeatedly in this list.

You can also use the above method using async / await:

const SerialPort = require('serialport');

(async () => {
    try {
        let ports = await SerialPort.list();
        console.log(ports); // Print serial port list } catch (error) {
        console.log(error);
    }
})();

Open Ports

By default, creating a SerialPort object will open the port, such as the following:

const SerialPort = require('serialport');

const port = new SerialPort('COM6', (err) => {
    if (err) {
        console.log('Port opening failed!');
        return;
    }
    console.log('Port opened successfully!');
});

The SerialPort class constructor has an autoOpen option that controls whether the port is automatically opened when the object is created. The default is to open the port automatically, but you can also turn it off so that you can open the port manually later:

const SerialPort = require('serialport');

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

port.open(function (err) {
    if (err) {
        console.log('Port opening failed!');
        return;
    }
    console.log('Port opened successfully!');
});

In the constructor of the SerialPort class, you can use the baudRate option to set the serial port communication baud rate, the default is 9600:

const SerialPort = require('serialport');

const port = new SerialPort('COM6', { baudRate: 115200 }); // Set the baud rate to 115200

For more information, please refer to the following section on the construction method of the SerialPort class.

Sending Data

You can use the write method of the SerialPort object to send data. This method puts the data to be sent into the send buffer and then sends it in sequence, such as the following:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

port.write('Hello world!\n'); // Send string port.write(Buffer.from('Hey!\n')); // Send Buffer data port.write(new Uint8Array([0x48, 0x69, 0x21, 0x0A])); // Send byte array 

The write method can also add a callback function:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

port.write('Hello world!\n', (err) => {
    if (err) {
        console.log('write operation failed!');
        return;
    }
    console.log('write operation successful!');
});

It should be noted that when the callback function above is triggered in a non-abnormal state, it only means that the write method itself has completed the operation, and does not mean that the data has been completely sent from the port. You can use the drain method to handle it. This method will block until the sending is completed:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

port.write('Hello world!\n');
port.drain(err => {
    if (err) return;
    console.log('Sending completed!');
});

Receiving Data

You can use the following methods to receive data:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

// Listen to received data in paused mode, and actively read data port.on('readable', () => {
    console.log(port.read()); // Use the read method to read data, you can specify the number of bytes to read});

// Listen to received data in flowing mode port.on('data', (data) => {
    console.log(data);
});

In addition to the above methods, you can also use pipe to transfer data to another stream.

Error handling

Most operations of the SerialPort object have callback functions, and the first parameter in the callback function is the exception object. In addition, you can also use the error event to uniformly handle exceptions:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

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

Data Parser

The SerialPort module has prepared some data parsers, which are mainly used to process some common forms of serial port data received. The main functions provided are as follows:

ByteLength Parser
Parse based on the length of the received data:

const SerialPort = require('serialport');
const port = new 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); // Print received data });

ccTalk Parser
Parse ccTalk format data, see: https://en.wikipedia.org/wiki/CcTalk

Delimiter Parser
Process data with specified characters as boundaries:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

const Delimiter = require('@serialport/parser-delimiter');
const parser = port.pipe(new Delimiter({ delimiter: '\n' })); // Process data separated by \n parser.on('data', chunk => {
    console.log(chunk.toString()); // Print received data });

The delimiter option can be string|Buffer|number[]; the includeDelimiter option indicates whether the delimiter is included in the data, which is not included by default.

InterByteTimeout Parser
No data received within the specified time triggers parsing:

const SerialPort = require('serialport');
const port = new SerialPort('COM6');

const InterByteTimeout = require('@serialport/parser-inter-byte-timeout');
const parser = port.pipe(new InterByteTimeout({interval: 2000})); // 2000 milliseconds without receiving data triggers parser.on('data', chunk => {
    console.log(chunk); // Print received data });

The maxBufferSize option is used to specify that an action will be triggered after receiving this amount of data even if there is no timeout.

Readline Parser
Parse data in lines. The default line separator is \n . You can use the delimiter option to reset it to something else, such as \r\n .

Ready Parser
Parsing starts with a flag.

Regex Parser
Parse using regular expressions as delimiters.

SerialPort Class

The main use of the SerialPort module is to use the SerialPort class, which is introduced in the Stream Interface chapter of the SerialPort module documentation: https://serialport.io/docs/api-stream. Here is a brief excerpt of some of the content.

Construction method

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

The constructor is used to create a serial port object, path is the serial port number, and openCallback is the callback function when automatic opening fails;

Common options of openOptions are as follows:

property

SerialPort has the following properties to read:
path 、 baudRate 、 isOpen 、 binding

event

The events triggered by SerialPort are as follows:

• Triggered when the open port is opened;
• error is triggered when an error is sent;
• close Triggered when the port is closed;
• data is triggered when data is received;
• drain If the write method returns false, the event will be triggered when the write method is called again;

method

Some of the methods available with SerialPort are as follows:

• open(() => {}): void opens the port;
• update(options: updateOptions, callback?: err => {}): void change the baud rate;
• write(data: string|Buffer|Array<number>, encoding?: string, callback?: error => {}): boolean sends data;
• read(size?: number): string|Buffer|null data;
• close(callback?: error => {}): void closes the port;
• set(options: setOptions, callback?: error => {}): void Set flow control;
• get(callback: (error, data: ModemStatus) => {}): void Get the flow control status of the opened port;
• flush(callback? error => {}):void Clear the unprocessed data in the receive and send buffers;
• drain(callback? error => {}):void for data to be sent;
• pause(): this pauses the flowing mode, triggers the data event, and switches to the paused mode;
• resume(): this resumes the data event and switches from paused mode to flowing mode;

Command Line Tools

The SerialPort module also provides some command line tools for use directly in the command line interface. The following is a demonstration of the use of the official website homepage:

For more information, refer to the Command Line Tools section in the SerialPort module documentation: https://serialport.io/docs/guide-cli

Summarize

The main usage of Node.js's SerialPort module is the above content.

Another point worth mentioning is that the SerialPort module does not directly operate the serial port, but calls the underlying interface on each platform to use the serial port. If you are developing related content or have special needs, you can refer to the Binding related content in the SerialPort module document.

This is the end of this article about the use of SerialPort (serial port) module in Node.js. For more relevant Node.js SerialPort content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!