Is there a common "standard" to send messages to a Linux host over serial/RS232?

Question

I do have an Arduino project that does stuff and then sends results out over it's serial port to a computer running Linux. This is a RS232 connection, 9600 Baud, connected either to a 9-Pin COM Port or using a USB/RS232 adapter (which in the end is the same any way).

Now, I can build my own reader using Minicom and reading from /dev/ttyS0 directly, but before I build my own solution, I wonder if there's already some kind of common standard - common sense tells me that in the decades of *NIX, someone must have already built something. But so far, I've mostly found information about manually reading or using the AT command set, which really doesn't apply here.

Something like "syslog over RS232" or so. I'm flexible in my data structure, and using some standard mechanism will allow other tools to also hook into it. I don't want to build the receiving software myself if there's already some standard software, and the eventual consumer of the data can then just pick it up from whatever standard place.

Addition: The data itself is essentially sensor data (got a few temperature sensors connected, and there are some buttons to turn on/off functionality) that I'm thinking of eventually sending as some OpenMetrics format - but as said, I'm pretty flexible and can do Arduino > RS232 > Linux > MyOwnConverter > EventualConsumer with an intermediary standard format (preferably human readable). The Linux side just needs to receive and store, the processing is then handled by an actual custom tool, I just prefer to have the "receive and store" part covered by existing tooling if feasible.

Answer 1

I'm not aware of anything specific to Linux. One of the more common standards for engineering with sensor data is Modbus

There are a few handy tools for testing under Linux (eg https://github.com/epsilonrt/mbpoll) and there are a lot of standard libraries for writing your own modbus master program. So you should be able to work with it in the language of your choice.

Ultimately this may mean you prefer to write your own software, but this would at least provide you with some structure.

---

Modbus is a request / response protocol. You would typically setup your host as a master and the sensors (Arduino) as a slave. This means you would continuously poll your Arduino rather than having the Arduino continuously stream data.

Modbus is written around the concept of registers. It provides the structure to request the value of registers as well as setting the value. So sensor hardware typically has each value (eg voltage, current, ac frequency) as a different register. Like giving instructions is framed in terms of setting a register.

Where I've seen it used, it was common to have a mix of float and integer registers as well as single values spanning multiple registers (eg to offer 64 bit values).

Answer 2

Firmata is another option. You have libraries to process it in many programming languages.

The Firmata library implements the Firmata protocol for communicating with software on the host computer. This allows you to write custom firmware without having to create your own protocol and objects for the programming environment that you are using.

You can read sensors and write outputs to the device as well as poll it.

For example, in Python, with this library:

Turn off the led at DIGITAL13

board.digital[13].write(0)

Read an analog input (read about the iterator):

board.analog[0].enable_reporting()
board.analog[0].read()

In the Arduino you just need to upload StandardFirmdata, that's it, you can start working right away without an sketch.