← Help contents

Sending Data

Plain text, raw bytes, a Modbus RTU frame or a whole file — all start here

The send bar sits at the bottom of the Connection tab, directly under the terminal. Everything you send by hand starts here — plain text, raw bytes, a Modbus RTU frame, or a whole file. Macros, triggers, Lua scripts and the AI assistant do not go through this bar: each of them sends its own bytes straight to the port, and shows up in the terminal under its own mark (TX_MCR, TX_TRG, TX_SCR, TX_AI — see the previous chapter).

The send bar — Format list, txt/hex fields with the line-ending column, CMD and LOOP buttons, file send

The Format list on the left picks what the bar shows: Text / Hex (one view with two fields) or Modbus RTU (a table of frame fields instead of the input). The choice is remembered between sessions.

Text and hex — one view, two fields

The upper row is labelled txt, the lower one hex. They are two views of the same command, kept in step while you type:

Type in the txt field and the hex row shows the bytes your text turns into. Escape sequences are honoured: \r, \n, \r\n and \t become real control bytes.
Type in the hex field and the spacing arranges itself — 0103 becomes 01 03, lower case turns into upper case, and a lone digit waits until you complete the byte.
Bytes that are not printable cannot be shown as text, so the txt field then shows a dot in their place and goes dimmed — a signal that you are looking at a reflection, not at content.

The field you last typed in — or simply clicked into — is the source. It decides which field a history entry goes back into, and whether the line ending is appended. The hex field is literal: nothing is added to what you typed, so a hand-typed Modbus frame never picks up two stray bytes at the end.

The line-ending column

The third column carries the line ending. The upper cell is a button: each click steps to the next value — None → CR → LF → CRLF. The cell underneath shows the bytes that value adds. LF is the starting value.

The hex row shows the content only: type AT with CRLF selected and you get 41 54 in the hex field and 0D 0A in the third column. The line ending is appended only when the text field is the source.

Sending a command

Press Enter in either field, or click the CMD button. After a successful send both fields are cleared and the cursor returns to the field you were typing in.

The terminal's right-click menu feeds this bar too: Add to Send appends the selected text to the txt field, and Send puts it in and sends it in one step.

Modbus RTU — a table instead of hand-typed hex

Switch Format to Modbus RTU and the input field is replaced by a two-row table with five fixed columns: Addr, Function, two columns whose headings follow the function, and CRC.

The function list lives in the Function header cell, in groups: the seven standard codes (01–06, 16) and Custom function… are always there, and a user defined group appears in between once you have named a code of your own in the terminal's FC window. The two middle headings follow the choice — Coil from / Count, Reg from / Count, Register / Value, Reg from / Values and so on.

Numbers may be decimal or hexadecimal with a 0x prefix — device manuals use both.
State (FC05) accepts ON/1/true or OFF/0/false.
Values (FC16) is a list separated by commas, semicolons or spaces — 10, 20, 30.
Changing to a function whose fields mean something else clears both variable fields; going from FC03 to FC04 keeps them. The device address always stays.

The CRC is calculated for you. A quarter of a second after your last keystroke the app builds the frame and fills the CRC column with its last two bytes; hovering that cell shows the complete frame. If the fields cannot form a frame, the CRC cell stays empty — and an empty CRC means there is nothing to send.

Custom functions: the cell under the list becomes a field for the code, read hexadecimally (44 means 0x44); add a trailing d for decimal. The third column becomes Data (hex) and carries the payload. The checksum is still appended for you.

Two differences from the Text / Hex view: Enter does not send in Modbus mode — use the CMD button — and the fields are not cleared after sending, so you can fire the same frame again or edit one value.

The clock next to the table opens a list of previously sent frames, laid out in the same columns. Click a row and its values drop straight back into the fields.

Command history

The clock icon inside the command field is the history control. It stays invisible until you hover over the field or put the cursor in it, and it glows when history is on; clicking it switches history off and on.

The list opens above the field when the field takes focus and filters down to entries containing what you have typed.
↑ / ↓ walk through the entries; each returns to the field it came from.
Repeated commands collapse to one row, and Modbus frames are left out — they have their own list.

The history holds up to 500 entries, lives in memory only and starts empty after every restart. It records only what a person typed — macros, triggers, Lua scripts, the assistant and file sends do not appear in it.

Sending in a loop

The LOOP button opens a small Interval (ms) field. That number is the switch — there is no separate toggle:

Set the interval — 1 to 60000 ms. 0 means “send once”: the bar then behaves like a single CMD click. The LOOP button lights up as soon as a non-zero interval is set.
Type your command and press CMD. The bytes are frozen at that moment and repeated unchanged.
While the loop runs the CMD icon turns into a red stop square, the LOOP icon spins, and the interval field is locked.
Press CMD again to stop it. Disconnecting the port stops it as well.

The interval is measured from the moment the loop started, so the work inside one pass does not stretch the period. If a send takes longer than the interval, the loop runs as fast as it can rather than firing a burst to catch up.

Sending a file

The two buttons on the right handle files. The rightmost picks the file; its tooltip then shows the file name. Picking a file does not send anything — the button to its left sends it, in 64-byte chunks, with the thin vertical bar in front of it filling as the transfer runs.

Right-click the send button to open Delay (ms) — a pause between chunks, 0 to 1000 ms, for devices that cannot swallow data at full speed.
While the file is going out, the same button shows a stop square. It stops at the next chunk boundary, so no half-frame is left behind.
File → Send file in the menu does both steps at once.

When the port is closed

Both input fields are greyed out and the txt field reads “Connect to send commands...”. The CMD and file send buttons are greyed out, the history list will not open, and a running loop is stopped the moment the port disconnects.

What still works: the Format list, the Interval (ms) panel and the whole Modbus RTU table. You can compose a frame and watch its CRC appear with the port closed — the checksum does not need the device. Only the moment of sending does.