Serial Terminal Emulator

Some serial protocols are text-based (e.g., Modbus ASCII), and some are binary (e.g., Modbus RTU). As a truly versatile serial terminal, IO Ninja doesn't limit you to one or the other and lets you choose the representation that works best in each particular case. If you need to, you can switch between the two kinds of data views at any time.

Serial communications do not only consist of incoming and outgoing data. There are control line changes (CTS/RTS/DSR/DTR), line errors (BREAK/PARITY/FRAME), serial setting adjustments (baud/data/stop/parity), and so on — you get the idea. IO Ninja records everything in a single continuous log sheet interleaving data bytes and informational messages — you have a clear and easy-to-follow timeline of events.

If you don't need these extra pieces of information — filter them out of the log to enjoy a clean and readable data view. However, nothing gets lost — all the serial event records can be brought back whenever you need them.

Having too much information before your eyes can be counterproductive. IO Ninja helps you focus on what's important by automatically highlighting data in the log based on regular expression (regex) patterns. If you need to, you can define multiple regex patterns and assign different visual attributes to each of those — and this does not introduce any additional performance penalty. Yes, finding and colorizing many patterns is just as fast as colorizing one — how cool is that?!

Many serial protocols use one of the standard checksums (CRC-8, CRC-16, SUM-8, XOR-8, etc.) to verify the integrity of data transmitted over an inherently lossy serial interface. IO Ninja calculates all standard checksums on the fly as you select data in the log; then, it conveniently displays the results in a table. Besides checksums, you also get local throughputs, time differences, byte offsets, data block lengths, etc.

Copy data from the log any way you want — as text, hex, C-array, etc. IO Ninja is smart and can guess what you want from the selection pattern — Ctrl+C always yields intuitive results. Of course, you can also explicitly state your intentions for how to copy the data via the context menu. You can save chunks of data directly into a file, too.

Sometimes, all you want is the classic terminal rendition of the incoming data stream. IO Ninja features a fully compatible X-Term terminal view, so if you must log in to an embedded Linux box over a serial link — you are all set!

Of course, all the in-depth information about the serial session is still there in the log view when you need it.

IO Ninja features convenient and powerful tools for preparing packets before transmission.

For text-based protocols, there is a plain text editor with support for escape sequences such as \r, \t, \x02, etc.

If you want to transmit a file, there is a file transmit pane — files can be sent using the X-Modem protocol or "as is."

However, it's in binary packet transmission where IO Ninja truly shines. Our modern hex editor supports Unicode, insert/overwrite modes, nibble editing, multiple copy modes, etc. And to complement this solid hex editor, we offer the Packet Template engine.

Even if you have a good hex editor, encoding the fields of a binary packet by hand is hard and error-prone — especially packets with checksums!

With the Packet Template engine, you can describe the packet structure in a C-like language, then conveniently modify all the fields using the property grid — without the need to calculate fields offsets, lengths, byte order, etc. And yes, there's support for the automatic calculation of checksums and other derivative fields!

Every time you transmit a packet, it goes to the Packet History pane. Need to re-transmit a particular packet? Double-click it! Want to inspect its contents? Hover your mouse over it! Have to modify the contents before transmission? Drag it back into the packet editor!

You can also build libraries of packets most commonly used in your line of work. The mnemonic names you assign to your packets make it easy to navigate through the packet library. And, of course, these mnemonics are automatically shown in the packet history pane, too!

With the Script Pane, you can generate packets programmatically, wait for and react to serial events, automatically respond to incoming packets, etc.

For example, here's how to send ten packets from cmd-1 to cmd-10:

void main() {
    for (size_t i = 1; i <= 10; i++)
        transmit($"cmd-$i\n");
}

Modbus RTU (especially over RS-485) is widely used in industrial automation, so IO Ninja provides you with great tooling for Modbus.

The Modbus Analyzer is a layer that decodes Modbus frames and adds human-readable descriptions to the log. The original data is complemented, not replaced — so nothing is lost.

The Packet Template Modbus Library helps you generate outgoing Modbus frames. Simply fill in the device address, function code, register/coil numbers, and other relevant information via the property grid — and the checksums will be calculated automatically.

You can connect over SSH and control serial ports on remote machines. Typically, those machines will be Linux boxes, but it's possible to share ports in Windows or macOS, too.

First of all, make sure the SSH server on the target machine is up and running. Then, install the IO Ninja Hardware Client -- and you can work with serial ports on this remote machine over SSH just like you do with local ports!

Last but not least, you can redirect your serial stream over a network via TCP, UDP, SSL, WebSocket, etc.

This IO Ninja feature is called Session Linking. To use it, start the second network session (e.g., WebSocket Server) without closing the original Serial one. Then, configure the relevant parameters (e.g., choose the TCP port to listen on) and click Link Sessions -- from now on, all the data received on one end will be transmitted to the other. Voila! Now you can connect to the serial port on your PC from your WebSocket application!