Reviving Legacy Systems: How to Use the Modern Serial Communication Dashboard Built with Python

Why did I create this tool? The answer might surprise you.

Most tech blogs today focus on AI, cloud, and other cutting-edge topics. Yet I chose to write about serial communication—specifically the so-called legacy technologies like RS-232 and RS-485.

People often ask, “Why bother with such an old field?” My response is simple.

Because many sites still rely on it every single day.

Factories and measurement facilities continue to operate equipment that was built decades ago. These machines are expensive, and replacing them isn’t realistic. “If it works, leave it alone” remains common wisdom on the shop floor.

Here’s the often overlooked reality.

Diving into this field isn’t about nostalgia. For engineers working in the trenches, this area is still very much active and critical.

For example—

• Many production machines and testers from 20 or even 30 years ago are still running
• They are controlled via serial communication like RS-232C and RS-485
• Updating them can cost hundreds of thousands or even millions of yen

Given these facts, it’s not enough to simply say, “Switch to something new.” Not interrupting a working system is a sound decision not just for costs but also for quality, deadlines, and avoiding trouble.

What about small and regional factories?

They face additional challenges. Budgets are tight. Many rely entirely on VBA and Excel, and moving everything to Python or .NET would require expensive outsourcing and training.

The key is to use current assets while gradually moving toward the future. That, to me, is real, practical support.

With this background, I created a tool called “Modern Serial Communication.” Next I’ll share its strategic value in more detail.

Strategic Value—Why Legacy Support Matters Now

If you’re reading this, you probably care more about keeping existing systems running than about chasing the latest tech.

The fact that you found this article shows there’s a niche yet real demand in this field.

Our mission is clear.

—Provide a gradual path forward.

Instead of ripping everything out, we show how to
step up without discarding what already works.

This is the greatest value of Modern Serial Communication.

A Bridging Tool for Today’s Equipment and Tomorrow’s Needs

Rather than installing a huge web dashboard right away, the tool starts with a Python + Textual terminal UI so that:

• It runs even on older PCs
• Setup is extremely lightweight
• It can connect directly to existing COM ports or TCP bridges

That makes for a friendly first step on the factory floor.

From there, it can expand with:

• CSV exports for working with Excel
• JSON Lines logs for automated analysis
• MQTT or WebSocket connections in the future

So you can scale up step by step.

Opportunities for Training and Consulting

The benefits go beyond software. Rolling out this tool can spark Python study in-house and lead to new perspectives on improving daily operations.

• You start hearing what the field really thinks
• Data begins to accumulate
• You gain the ability to analyze it
• Proposals have a better chance of approval

In short, better technology can even improve communication.

Setup Steps—Your Smooth First Start

This tool works on Windows, Linux, or macOS as long as Python 3.8 or later is available. All it takes is a few steps.

1. Download the Project from GitHub

Clone the official repository. (If you don’t use Git, feel free to download the ZIP.)

git clone https://github.com/superdoccimo/modern-serial-communication.git
cd modern-serial-communication

2. Python Virtual Environment (Recommended)

Create a virtual environment so it doesn’t interfere with other Python projects.

python -m venv venv
source venv/bin/activate   # On Windows: venv\Scripts\activate

3. Install the Required Libraries

Everything you need is listed in requirements.txt.

pip install -r requirements.txt

That’s all the prep you need.

4. Start the Serial Dashboard

Now let’s launch the real-time dashboard.

python serial_dashboard.py

You’ll see a graphical TUI on your console, ready for port input and data monitoring.

Using the Dashboard—Connect, Send, and Log

When you start Modern Serial Communication, you’ll see a polished TUI. Here’s what it looks like right after launch.

Connection Panel

In the upper left “Connection Control” area, enter the port you want to use.

• COM ports such as COM1 or /dev/ttyUSB0
• For virtual environments or VMs: a TCP bridge like socket://localhost:5000

After entering the port, click [Connect] to start real-time monitoring. A message “Connected” appears in the log once it succeeds.

Send Panel

Once connected, you can send any string from the “Send Data” panel in the lower right.

For instance, try sending this:

SENSOR,01,25.30,TEMP

After sending, you’ll see a blue message in the log, and the central data table updates.

Receive Log and Sparklines

Received data is logged with an “RX” label and displayed as a sparkline, making the flow and density easy to see.

The “Statistics” panel on the lower right continuously updates with:

• Number of received and sent packets
• Total bytes
• Elapsed time and average rate

This information refreshes automatically.

Save Received Data as CSV

Data isn’t just displayed. Press a single key to save it as CSV.

Press s and the current buffer exports to a CSV file.

The filename is generated automatically like this:

serial_data_20250605_173212.csv

The CSV contains data in this format:

This makes it easy to load into Excel, spreadsheets, or BI tools.

Change Settings Easily with serial_config.ini

You can adjust port settings or TCP targets by editing serial_config.ini directly.

For a typical COM port:

[SERIAL]
port = COM1
baudrate = 9600
bytesize = 8
parity = N
stopbits = 1
timeout = 1.0

For a TCP bridge via a VM or another machine:

[NETWORK]
tcp_host = 192.168.0.100
tcp_port = 5000
use_tcp = true

This file loads automatically at startup, so you don’t have to specify command-line options each time.

Verify Operation with the Test Sender Script

You don’t need physical serial gear on hand. The project includes a script that sends sample data through a virtual port (e.g., COM2→COM1).

Run it like this:

python test_data_sender.py

The script periodically sends various kinds of data:

• Sensor readings (temperature, humidity, pressure)

• Status notifications
• Composite JSON messages
• Bulk transmit mode for stress testing

This lets you test with confidence even without real hardware.

The Key Differentiator—Flexibility for Anyone to Extend

Commercial serial tools may be stable and full of features, but they often come with limitations:

• They are black boxes—you can’t see what’s happening inside
• They usually work only on certain OSes (typically Windows)
• Commercial licenses cost money, and customization requires extra fees
• Data saving or external integration is reserved for premium editions

Modern Serial Communication takes the opposite approach.

Anyone Can Modify It Whenever Needed

Because the tool is built with plain Python and popular libraries, field engineers or students can easily add features such as:

• Preset messages for sending
• Automatic filters for incoming data
• Automatically save logs to S3 or Google Drive
• Trigger voice or Slack alerts on errors
• Integrate with custom protocols like Modbus

All it takes is changing a few lines of source code.

Real-World Extensions

Users have already reported implementations such as:

• 24/7 monitoring on small Linux devices like Raspberry Pi
• Publishing data via MQTT through an IoT gateway
• Localizing the Textual UI into English or Chinese
• Custom builds that automatically reconnect after errors

Commercial tools would require a license or paid development for these capabilities.

Use Cases and Success Stories

The project is still young, yet it’s already being adopted in several workplaces and development efforts.

Here are a few real-world examples.

Manufacturing: Connecting an Old Inspection Machine

At one regional factory, a 1990s inspection unit with temperature and pressure sensors still runs. It sends data via RS-232. Previously the process was:

1. Monitor with Windows XP and HyperTerminal
2. Record the values manually
3. Sometimes print screenshots onto paper

It was the epitome of a manual, paper-based workflow.

After adopting Modern Serial Communication:

• Data appears in tables in real time
• You can save it as CSV for Excel processing
• Months of records accumulate in JSON Lines

This brought a step toward digital transformation without retraining the staff.

Education: Protocol Analysis in Technical School

A technical college adopted the tool for lab exercises. Students pair up with one PC and two USB–serial converters.

• One side sends mock sensor data
• The other watches the TUI logs and stats

The curriculum lets them experience both sending and analyzing. Because the entire code is readable, it works well as a teaching aid and naturally connects to Python basics.

Development Support: Firmware Debugging

Some embedded developers use the tool to monitor UART debug logs.

• Filtered log display
• Error pattern detection by string match
• Highlight specific phrases using Textual CSS

With such customizations, many report greatly improved development efficiency.

Thus, Modern Serial Communication is not just a monitor; it’s a growing platform tailored to real-world problems.

Future Plans—For More Flexibility and Ongoing Development

Development continues, aiming for even wider use. Here are some planned updates and expansions.

Features Coming Soon

• WebSocket output
  Send data to the browser in real time for web-based visualization and cloud integration.
• MQTT integration for IoT
  Publish data to MQTT with an eye toward connecting to Node-RED or Home Assistant.
• Plugin architecture for custom protocols
  Prepare a framework so you can easily add decoding for Modbus or proprietary protocols.
• Advanced filtering
  Extract, display, and notify only the data you need, making monitoring and error detection more efficient.

Long-Term Ideas

• Web-based GUI options
  Alongside the TUI, consider an Electron or FastAPI-based GUI.
• Integration with SQLite or InfluxDB
  Support long-term logging, queries, and time-series analysis.
• Simultaneous monitoring of multiple ports
  Display several COM ports on one screen.
• Templates for serial protocol decoders
  Include standard protocols like Modbus ASCII or NMEA 0183.

How to Contribute—Open Development for Everyone

Modern Serial Communication is completely open source under the MIT license. Clone, modify, and redistribute from GitHub, and help in any of these ways.

To Help with Development or Improvements:

• Fork the repository and send a Pull Request
  https://github.com/superdoccimo/modern-serial-communication
• File issues to report bugs or propose improvements
• Share your own extension code (filters, Slack integration, etc.)
• Add documentation or translations
• Publish articles or videos showing real use cases

In Closing—Old Technology Is Exactly What We Need

People love to talk about AI and the latest trends. But what many workplaces truly need is technology that bridges existing assets to the future.

Modern Serial Communication was created to answer those voices. If you found this article helpful, please star the GitHub repo or share it with others facing the same challenges.

For running the server on Linux, see the article below.

A certain site

Ubuntu Serial Port Setup and VMware Dual-Pipe Communication with Python A complete guide to configuring serial ports on Ubuntu, adding users to the dialout group, and achieving reliable bidirectional communication in VMware using na…