How can I mock serial port during development? - node.js

Question

I am developing a node.js application for my Raspberry Pi which receives data from its serial port, but I don't directly develop the application on it, I use my main computer instead. So I have this code in my app.js :
var serialport = require("serialport");
var SerialPort = serialport.SerialPort;
var sp = new SerialPort("/dev/ttyACM0", {
parser: serialport.parsers.readline("\n")
});
sp.on("data", function (rawData) {
...
This works well on the Rasperry Pi but I want to be able to run the application on my development computer first without having to comment every block of code about the serial port.
What is the best way to achieve this ? Is there a way to mock the serial port ?

Answer 1

AFAIK, there aren't any libraries that do this natively right now. What I've done in the past is to use the node-serialport library's own test code as an example, eg: https://github.com/Manetos/node-serialport/blob/157e6f9df7989abd72d509c9827d13b2b10258de/test_mocks/linux-hardware.js
If you take a look at that file, they're mocking the serial port behavior for their own tests, you can simply copy what they're doing there and use it in your stuff, and you should be good to go.
Hope that helps!

Answer 2

I needed the same thing and wasn't able to find details of exactly how to do it, but I kept hitting this question in my searches. After a bit of researching and finding a few vague references in different areas, I was able to put together the following. Hopefully this will be helpful to others who might land here.
You can extend the SerialPort - MockBindings class with your own and then simply implement a custom write function that will receive the data, form a proper response, then emit it back to the caller.
const MockSerialBinding = require('#serialport/binding-mock');
class EmulatedDeviceSerialBinding extends MockSerialBinding {
constructor(opt = {}) {
super(opt);
}
// THIS IS THE METHOD THAT GETS TRIGGERED WHEN THE CODE TO TEST WRITES TO A DEVICE
async write(buffer) {
// Use this method to detect the supported commands and emulate a response
const cmd = Buffer.from(buffer).toString();
let response = 'Unknown Command!'; // Default response
// Custom logic here to determine the proper response
super.emitData(response);
}
}
module.exports = EmulatedDeviceSerialBinding;
For your test, prepare a fake serial device that can be targeted that uses the class above:
const SerialPort = require('serialport');
SerialPort.Binding = EmulatedDeviceSerialBinding;
// Setup a new mock serial device that can be the target
EmulatedDeviceSerialBinding.createPort('ttyUSB_TestTarget', {
echo: true,
readyData: '\r\nhostname#user:~$ ' // This will append a 'prompt' to the end of each response (like a linux terminal would)
});
Now your logic would be the same except you'd connect to the emulated device port instead of a real port. Here is a snippet from an Express Route Middleware:
const SerialPort = require('serialport');
const SerialRegexParser = require('#serialport/parser-regex');
const serialParser = new SerialRegexParser({regex: /(?<Prompt>.*[$#]\s*$)/m});
const serialPortOptions = {
baudRate: 115200
};
// The req.params.devicePort value be the name of the emulated port
const port = new SerialPort(req.params.devicePort, serialPortOptions, (err) => {
if (err) {
return res.status(400).send({error: err.message});
}
});
port.pipe(serialParser);
// THIS WILL BE TRIGGERED WHEN THE EmulatedDeviceSerialBinding does the emitData call
serialParser.once('data', (data) => {
if (res.headersSent) return; // We've already responded to the client, we can't send more
const dataString = Buffer.from(data).toString();
// Remove the command executed from the beginning if it was echoed
respDoc.data = dataString.replace(cmdToExecute, '').trimEnd();
return res.send(respDoc);
});
// Send the command to the device
// THIS WILL TRIGGER THE EmulatedDeviceSerialBinding.write() FUNCTION
port.write(cmdToExecute, (err) => {
if (err) {
return res.status(400).send({error: err.message});
}
});
The program flow is:
Express Middleware port.write(cmdToExecute)
-> EmulatedDeviceSerialBinding.write()
-> Express Middleware serialParser.once('data') callback

Answer 3

I was able to achieve this using the com0com modem emulator available at https://sourceforge.net/projects/com0com/
It will create two virtual COM ports (eg. COM5 and COM6) which map to each other. You can connect your application to one of the COM ports and your emulator code to the other COM port. The emulator can then be configured to read the input and write back out accordingly.