MeshRadio Console GUI – Live Monitoring and Control Center for MeshRadio Nodes
The MeshRadio Console GUI is a practical desktop application for live monitoring, visualization, and control of MeshRadio sensor and actuator nodes. It was specifically developed for use in experimental radio networks, telemetry applications, sensor networks, and amateur radio projects, combining a clear graphical interface with robust serial communication.
The software is aimed at users who want not only to receive MeshRadio nodes, but also to monitor, evaluate, and control them in a targeted way. The main focus is on ease of use, clear status indication, and reliable command triggering based on incoming radio messages.
Here is a short step-by-step guide for installing Python for the MeshRadio Console GUI under Windows:
-
Download and install Python
Visit the official website: Go to the Python Downloads page. <- Click here to download.
Choose a version: Click the button for the latest Python 3 version (for example Python 3.13).
Start installation: Run the downloaded .exe file.
IMPORTANT: Make sure to check the box “Add Python to PATH”. Without this step, you will not be able to use Python easily from the command line later.
Standard installation: Select “Install Now”.
-
Verify the installation
Press Windows key + R, type cmd, and press Enter.
Type python –version. If a version number appears, the installation was successful.
Check with pip –version whether the package manager is also ready.
Required libraries: pip install pyserial matplotlib
Startup Parameters of the MeshRadio Console GUI
The MeshRadio Console GUI can be adapted to different systems and operating conditions using various startup parameters. This allows the program to be configured flexibly for different hardware setups, radio networks, or development environments.
The parameters are passed on the command line when starting the program.
A typical startup looks like this:
python .\meshradio_console_gui.py –port COM16 –baud 115200 –window 30
This starts the software with a specific serial interface, a defined baud rate, and a TX time window.
All available parameters are described below.
–port
–port PORT
This parameter specifies which serial port is used.
The software receives the MeshRadio system messages through this interface.
Typical values:
Windows
COM3
COM5
COM16
Linux
/dev/ttyUSB0
/dev/ttyACM0
macOS
/dev/cu.usbserial
Example:
python .\meshradio_console_gui.py –port COM16
Default value:
COM16
–baud
–baud BAUDRATE
This parameter defines the baud rate of the serial connection.
The baud rate must match the setting of the MeshRadio device.
Typical values:
9600
57600
115200
Default value:
115200
Example:
python .\meshradio_console_gui.py –baud 115200
–timeout
–timeout SECONDS
This parameter defines the timeout value for reading from the serial port.
If no data is received within this period, the read operation returns and the program loop continues.
Default value:
0.2 seconds
Example:
python .\meshradio_console_gui.py –timeout 0.2
The default value offers a good balance between:
responsiveness
CPU load
stable GUI updates
–window
–window SECONDS
This parameter defines the duration of the send window after an AWAKE message.
When a sensor node sends a message such as
SENSOR:AWAKE
the software recognizes that the node is currently active. From that moment, a TX window is opened.
Within this time window, commands may be sent to the node.
Default value:
30 seconds
Example:
python .\meshradio_console_gui.py –window 20
This keeps the send window open for only 20 seconds.
This function is especially important for low-power wakeup nodes that are active only briefly.
–dst
–dst CALLSIGN
This parameter defines the default target for transmitted commands.
If no other target is entered in the GUI, the program uses this value.
Default value:
DL1ABCF
Example:
python .\meshradio_console_gui.py –dst DL7ABCF
The value can be changed at any time in the DST field of the GUI.
–max-points
–max-points NUMBER
This parameter determines how many measurement points are stored in the WX chart.
The values are stored internally in a ring structure. As soon as the maximum number is reached, the oldest data is automatically overwritten.
Default value:
300
Example:
python .\meshradio_console_gui.py –max-points 600
A higher value results in:
longer chart histories
higher memory usage
For normal applications, the default value is sufficient.
–always-allow-tx
–always-allow-tx
This parameter disables TX window protection.
Normally, the software allows sending commands only within the time window after a SENSOR:AWAKE message.
If this parameter is set, commands can be sent at any time, regardless of the wakeup state of the node.
Example:
python .\meshradio_console_gui.py –always-allow-tx
This option is especially useful for:
development environments
test operation
manual diagnostics
direct control without wakeup mechanism
In normal operation with battery-powered nodes, this option should usually not be enabled.
Complete Startup Example
A complete startup could look like this:
python .\meshradio_console_gui.py ^
–port COM16 ^
–baud 115200 ^
–window 30 ^
–dst DL7ABCF ^
–max-points 300
This starts the MeshRadio Console GUI with:
serial interface COM16
baud rate 115200
TX window 30 seconds
target node DL7ABCF
maximum 300 chart points
Purpose and Area of Use
In typical MeshRadio applications, remote nodes regularly send status or sensor data. This may include temperature, air pressure, humidity, battery voltage, or simple wake-up messages from a battery-powered node. This is exactly where the MeshRadio Console GUI comes in: it receives the serial output messages of the MeshRadio system in real time, processes them, and displays them in a convenient user interface.
The application is especially suitable for:
sensor stations in the MeshRadio network
battery-powered wakeup nodes
remote control of relay or switching functions
telemetry and weather data acquisition
amateur radio experiments with networked nodes
development, test, and diagnostic environments
Operating Principle
The program listens on a serial interface to which a MeshRadio system is connected. Incoming text messages are analyzed and processed further depending on their content. When a sensor node message is recognized, the application can extract both measurement values and status information from it.
The handling of AWAKE messages is particularly important. As soon as a node sends a message such as SENSOR:AWAKE, the software recognizes that this node is currently active and reachable. This allows a time window to be opened automatically during which commands may be sent to that node. This is especially critical for low-power or cyclically waking devices.
Graphical User Interface
The MeshRadio Console GUI consists of two main areas:
-
WX Plot Window
The plot window displays received weather and telemetry data live. This includes:
temperature
air pressure
relative humidity
battery voltage in millivolts
battery level in percent
The charts update continuously whenever new complete WX datasets are received. This provides direct visual feedback about the current state of the remote node and its progression over time.
-
Control Panel
The control window provides all important operating elements for live use:
display of the current TX time window
input field for destination callsign or destination node
free entry of custom payloads
quick buttons for standard commands such as:
RELAY ON
RELAY OFF
RELAY TOGGLE
STATUS?
one-shot auto command for automatic sending on the next AWAKE
link quality display based on the last RSSI value
node list with recently seen nodes
This makes the software suitable for both manual operation and semi-automatic workflows.
Automatic Triggering on AWAKE
A central feature of the application is the reliable triggering on incoming AWAKE messages. This means not only complete sensor datasets with weather values are recognized, but also simple messages such as:
SENSOR:AWAKE
As soon as such a message arrives, it is interpreted as a valid wake-up of the node. This allows:
the TX window to be opened,
the node to be marked as “last seen”,
a prepared auto command to be sent exactly at that moment.
This behavior is essential especially for sleep/wakeup-based sensor nodes, because not every radio frame already contains complete WX data. The software therefore deliberately reacts even to pure AWAKE messages and thus ensures robust control in real operation.
One-shot Auto Command
For many applications, it is necessary that a certain command is not sent immediately, but only when a node wakes up the next time. This is exactly what the one-shot auto command function is for.
The user enters a command and arms it in the interface. The software then waits for the next valid SENSOR:AWAKE message and automatically sends the command exactly once. After that, the auto trigger is deactivated again.
This is ideal for:
low-power nodes that are reachable only briefly
targeted switching actions
status queries on wakeup nodes
precisely timed one-time actions without constant manual intervention
TX Window Protection
To avoid incorrect transmissions or unnecessary transfers outside a meaningful communication window, the software includes TX window protection. After an AWAKE message, the send window remains open for a defined time. Within this period, commands can be triggered in a targeted way.
This state is clearly displayed in the interface:
green when the send window is open
gray when it is closed
In addition, a countdown is shown indicating how long the window remains open. This significantly improves usability and reduces operating errors.
Link Quality and RSSI Evaluation
The software evaluates available RSSI information from received messages and derives a simple link quality display from it. This gives the user an immediate impression of the current radio connection to the node.
The display includes:
the last known RSSI value in dBm
a derived quality percentage
a graphical bar display
This makes it easier to assess range, reception quality, and antenna conditions during operation.
Node List with “Last Seen”
All recognized nodes are maintained in a clear table. Among other things, it shows:
callsign or node name
time since last reception
last RSSI value
derived link quality
This makes it possible to see at a glance which nodes are currently active, when they were last received, and how good their radio connection is. This function is especially helpful in larger MeshRadio setups with multiple participants.
Robust Processing of Serial Messages
The application was designed so that it can reliably handle the typical serial text outputs of a MeshRadio system. Information such as from=…, rssi=…, SENSOR:AWAKE, and optional WX data are recognized flexibly.
The program therefore processes both:
pure AWAKE messages
combined AWAKE and WX telemetry
status lines with RSSI and sender identification
varying timing and irregular data streams
This robustness is especially important in real field operation, where not every message always has the same structure.
Typical Application Scenarios
The MeshRadio Console GUI is ideally suited for practical real-world applications. Examples:
Remote control of a relay node
A remote node wakes up briefly and sends SENSOR:AWAKE. The GUI detects this, opens the send window, and automatically transmits a prepared switching command such as CMD:RELAY ON.
Environmental or weather monitoring
A MeshRadio sensor node regularly provides temperature, air pressure, humidity, and battery data. The software visualizes these values live and documents their history directly in the plot window.
Monitoring of multiple nodes
In a small MeshRadio network with several participants, the node list immediately shows which stations were recently active and with what signal strength they were received.
Development and test environment
When developing new node software or protocol extensions, the GUI serves simultaneously as a live monitor, trigger console, and diagnostic tool.
Technical Basis
The application is written in Python 3 and uses proven standard and open-source components:
pyserial for serial communication
Tkinter for the graphical user interface
matplotlib for live display of measurement values
threading for parallel operation of GUI and serial processing
Thanks to this architecture, the program remains lightweight, portable, and easy to adapt. It is suitable for Windows systems as well as other platforms, provided Python and the required libraries are available.
Special Features of the Software
What makes the MeshRadio Console GUI special is the combination of:
live telemetry
visual status display
manual control
automatic triggering
node-specific overview
practical radio diagnostics
The software is not just a viewer, but a true working console for MeshRadio nodes.
Who Is This Application Intended For?
The MeshRadio Console GUI is aimed in particular at:
radio amateurs
developers and makers
operators of experimental sensor networks
users of battery-powered wakeup nodes
users of telemetry and switching applications in the MeshRadio environment
It is suitable both for practical operation and for use in the lab, workshop, test site, and field trials.
Summary
The MeshRadio Console GUI is a powerful yet clear monitoring and control application for MeshRadio systems. It enables the reception, evaluation, and display of sensor data in real time, reliably detects AWAKE states of remote nodes, and supports both manual and automatic commands within the optimal send window.
With live plots, node lists, RSSI-based link evaluation, status display, and auto-trigger function, it provides a tool specifically developed for the requirements of modern MeshRadio projects – practical, robust, and ready to use.