Created by Luca Schenetti — github.com/LucaSchenetti
Read — block-list reads |
Write — list writes |
Monitor — live time chart |
Server — datastore editor |
Log — raw frames & statistics |
Multi-protocol desktop client and server with a modern GUI (PySide6 / Qt 6). Four industrial protocols, each with its own complete Connection / Read / Write / Monitor / Server section:
| Protocol | Client | Server / simulator |
|---|---|---|
| Modbus RTU (RS-485) and TCP/IP | all functions 0x01-0x17, data types, bus scan, 0x2B | RTU/TCP slave with editable 0-65535 datastore |
| PROFINET S7 (Siemens S7comm) | DBs/flags/inputs/outputs, S7 types, CPU identification | simulated PLC exposing DB/M/I/Q with a byte editor |
| EtherNet/IP (CIP) (Allen-Bradley/Logix) | symbolic tags and arrays, List Identity | simulated PLC exposing CIP tags with a value editor |
| CANopen | SDO by index/subindex, node scan | simulated node with a user-defined Object Dictionary |
Every section has automatic polling, a watch list with a time chart, a shared transaction log and an independent status LED in the sidebar.
Fieldbus Studio is distributed as a ready-to-run Windows executable — no Python, no installation and no dependencies to set up.
- Open the Releases page.
- Download the latest
Fieldbus_Studio.exe. - Double-click to launch it.
Windows only. On the first launch Windows SmartScreen may warn about an unrecognised publisher (the app is not code-signed): click More info → Run anyway.
The app ships with built-in simulators for all four protocols, so you can test everything on a single PC with nothing connected. In each protocol's Server section you start a simulated device, then connect the client to it from the Connection section:
- Modbus — start a TCP server on
127.0.0.1:5020, then connect the client in TCP with the same parameters. Client writes appear live in the server datastore table and vice versa. - PROFINET S7 — start the simulated PLC (port
10102), then connect the client to127.0.0.1:10102(rack 0, slot 1). - EtherNet/IP — define the tags (e.g.
Temperature = REAL), start the simulator (port44818, takes a few seconds), then connect the client to127.0.0.1. - CANopen — start the node on the virtual interface (channel
test), then connect the client on the same virtual interface/channel and Node ID.
- RTU and TCP connection with dedicated panels: auto-detected serial port with a Refresh button, baudrate (presets + free value), parity, data/stop bits (RTU); host/IP and port (TCP); Slave/Unit ID (0–247) and timeout. Status LED, save/load profiles as JSON and last-profile memory.
- Block-list reads (same model in every section): add the blocks you want —
each with its address, function/area, data type and element count — and
"Read" (or the polling) reads them in sequence. The results table mirrors the
list instantly and updates in place with no flicker; a block in error shows
ERRwithout stopping the others. Lists save/load as JSON, results export to CSV, and everything is remembered across sessions. - List writes (same model in every section): add the writes — each with its function/address/type/value — and "Write all" / "Write selected" sends them in sequence with a per-row result (✓/✗). Modbus supports 0x05, 0x06, 0x0F, 0x10, 0x16 Mask Write and 0x17 Read/Write Multiple, with input validation and spec limits.
- Typed writes: values entered directly as int16/uint16, int32/uint32, float32/float64 or ASCII text, with selectable byte and word order; the conversion into registers is automatic.
- Data types: int16/uint16, int32/uint32, float32 (IEEE754), float64, ASCII string, with selectable byte order and word order.
- Automatic polling with a millisecond interval and live updates.
- Automatic reconnection: if the device drops during polling, the app closes the dead connection and retries with the last parameters until it is back.
- Monitor / register map: named entries (function, address, type, orders), saveable as JSON and importable/exportable as CSV. Ticked entries are plotted on a time chart (X = HH:MM:SS, Y = round numbers from 0); the mouse wheel zooms, a double-click auto-scales, hovering shows a tooltip. PNG and CSV export.
- IT/EN language: a sidebar selector that translates the whole interface live — buttons, labels, tooltips, placeholders, combo items, headers, dialogs and the status bar — and remembers the choice.
- Unit ID scan: probes a 1-247 range and lists the slaves that respond. Cancellable.
- Device identification 0x2B: reads vendor, product code, revision, etc. of the connected device.
- Communication statistics: request/OK/timeout/exception/error counters and last/min/avg/max response times, resettable.
- Transaction log with timestamps (TX/RX/errors), Modbus exception decoding,
save to file and continuous recording with automatic rotation (~5 MiB →
.1). - UART/Modbus frame debug: shows the raw bytes transmitted and received on the wire — UART frames (ADU + CRC) for RTU, Modbus/TCP frames (MBAP + PDU) for TCP.
- Server mode: the application becomes a Modbus RTU or TCP slave, exposing the whole 0-65535 address space for Holding/Input Registers and Coils/Discrete Inputs; values can be viewed and edited live (hex too), saved/ reloaded as JSON, and set by data type. Every protocol also has a simulated server (S7 PLC, EtherNet/IP PLC, CANopen node).
- Baudrate up to 3 Mbaud (CP2102N limit) with presets 230400/460800/921600/ 1M/2M/3M plus a free value.
- Modern sidebar interface with collapsible per-protocol sections, rounded cards, one status LED per protocol, resizable columns.
- Dark/light theme switchable at runtime, with log colours adapted to the theme.
- All communication runs in a worker thread: the GUI never freezes, not even on timeouts.
The PC connects to the PCB through a CP2102N USB-UART bridge with a THVD1424 RS-485 transceiver. The half-duplex direction (DE/RE) is handled by the CP2102N hardware (RS-485 mode with automatic RTS): the software does not control RTS. The port is treated as a normal COM port.
To test with real hardware: connect the PCB (CP2102N), press Refresh, select the port, set baudrate/parity to match the device, connect and read/write.
Client e server desktop multi-protocollo con un'interfaccia moderna (PySide6 / Qt 6). Quattro protocolli industriali, ognuno con la propria sezione completa Connessione / Lettura / Scrittura / Monitor / Server:
| Protocollo | Client | Server / simulatore |
|---|---|---|
| Modbus RTU (RS-485) e TCP/IP | tutte le funzioni 0x01-0x17, tipi di dato, scansione del bus, 0x2B | slave RTU/TCP con datastore 0-65535 modificabile |
| PROFINET S7 (Siemens S7comm) | DB/merker/ingressi/uscite, tipi S7, identificazione CPU | PLC simulato che espone DB/M/I/Q con editor a byte |
| EtherNet/IP (CIP) (Allen-Bradley/Logix) | tag simbolici e array, List Identity | PLC simulato che espone tag CIP con editor dei valori |
| CANopen | SDO per indice/sottoindice, scansione nodi | nodo simulato con Object Dictionary definito dall'utente |
Ogni sezione ha polling automatico, una watch list con grafico temporale, un log delle transazioni condiviso e un LED di stato indipendente nella barra laterale.
Fieldbus Studio è distribuito come eseguibile Windows pronto all'uso — niente Python, niente installazione e nessuna dipendenza da configurare.
- Apri la pagina delle Releases.
- Scarica l'ultimo
Fieldbus_Studio.exe. - Fai doppio clic per avviarlo.
Solo Windows. Al primo avvio Windows SmartScreen potrebbe segnalare un editore non riconosciuto (l'app non è firmata): clicca Ulteriori informazioni → Esegui comunque.
L'app include simulatori integrati per tutti e quattro i protocolli, così puoi provare tutto su un solo PC senza niente collegato. Nella sezione Server di ogni protocollo avvii un dispositivo simulato, poi colleghi il client dalla sezione Connessione:
- Modbus — avvia un server TCP su
127.0.0.1:5020, poi collega il client in TCP con gli stessi parametri. Le scritture del client compaiono in tempo reale nella tabella del datastore del server e viceversa. - PROFINET S7 — avvia il PLC simulato (porta
10102), poi collega il client a127.0.0.1:10102(rack 0, slot 1). - EtherNet/IP — definisci i tag (es.
Temperature = REAL), avvia il simulatore (porta44818, ci mette qualche secondo), poi collega il client a127.0.0.1. - CANopen — avvia il nodo sull'interfaccia virtual (canale
test), poi collega il client sulla stessa interfaccia/canale virtuale e Node ID.
- Connessione RTU e TCP con pannelli dedicati: porta seriale rilevata automaticamente con pulsante Refresh, baudrate (preset + valore libero), parità, bit di dati/stop (RTU); host/IP e porta (TCP); Slave/Unit ID (0–247) e timeout. LED di stato, salvataggio/caricamento profili in JSON e memoria dell'ultimo profilo.
- Letture a lista di blocchi (stesso modello in ogni sezione): aggiungi i
blocchi che vuoi — ognuno con indirizzo, funzione/area, tipo di dato e numero
di elementi — e "Leggi" (o il polling) li legge in sequenza. La tabella dei
risultati rispecchia la lista all'istante e si aggiorna sul posto senza
sfarfallio; un blocco in errore mostra
ERRsenza fermare gli altri. Le liste si salvano/caricano in JSON, i risultati si esportano in CSV e tutto viene ricordato tra le sessioni. - Scritture a lista (stesso modello in ogni sezione): aggiungi le scritture — ognuna con funzione/indirizzo/tipo/valore — e "Scrivi tutto" / "Scrivi selezionati" le invia in sequenza con un esito per riga (✓/✗). Modbus supporta 0x05, 0x06, 0x0F, 0x10, 0x16 Mask Write e 0x17 Read/Write Multiple, con validazione dell'input e limiti da specifica.
- Scritture tipizzate: valori inseriti direttamente come int16/uint16, int32/uint32, float32/float64 o testo ASCII, con ordine di byte e word selezionabile; la conversione in registri è automatica.
- Tipi di dato: int16/uint16, int32/uint32, float32 (IEEE754), float64, stringa ASCII, con ordine di byte e word selezionabile.
- Polling automatico con intervallo in millisecondi e aggiornamento live.
- Riconnessione automatica: se il dispositivo cade durante il polling, l'app chiude la connessione morta e riprova con gli ultimi parametri finché non torna disponibile.
- Monitor / mappa dei registri: voci con nome simbolico (funzione, indirizzo, tipo, ordini), salvabili in JSON e importabili/esportabili in CSV. Le voci spuntate vengono tracciate su un grafico temporale (X = HH:MM:SS, Y = numeri tondi da 0); la rotella del mouse zooma, il doppio clic torna all'auto-scala, il passaggio del mouse mostra un tooltip. Esportazione PNG e CSV.
- Lingua IT/EN: un selettore nella barra laterale che traduce tutta l'interfaccia in tempo reale — pulsanti, etichette, tooltip, placeholder, voci dei menu a tendina, intestazioni, dialoghi e barra di stato — e ricorda la scelta.
- Scansione Unit ID: sonda l'intervallo 1-247 ed elenca gli slave che rispondono. Annullabile.
- Identificazione dispositivo 0x2B: legge vendor, codice prodotto, revisione, ecc. del dispositivo collegato.
- Statistiche di comunicazione: contatori richieste/OK/timeout/eccezioni/ errori e tempi di risposta ultimo/min/medio/max, azzerabili.
- Log delle transazioni con timestamp (TX/RX/errori), decodifica delle
eccezioni Modbus, salvataggio su file e registrazione continua con rotazione
automatica (~5 MiB →
.1). - Debug frame UART/Modbus: mostra i byte grezzi trasmessi e ricevuti sul filo — frame UART (ADU + CRC) per RTU, frame Modbus/TCP (MBAP + PDU) per TCP.
- Modalità server: l'applicazione diventa uno slave Modbus RTU o TCP, esponendo tutto lo spazio di indirizzi 0-65535 per Holding/Input Register e Coil/Discrete Input; i valori si possono vedere e modificare in tempo reale (anche in hex), salvare/ricaricare in JSON e impostare per tipo di dato. Ogni protocollo ha anche un server simulato (PLC S7, PLC EtherNet/IP, nodo CANopen).
- Baudrate fino a 3 Mbaud (limite CP2102N) con preset 230400/460800/921600/ 1M/2M/3M oltre ai classici, più un valore libero.
- Interfaccia moderna a barra laterale con sezioni per protocollo richiudibili, card arrotondate, un LED di stato per protocollo, colonne ridimensionabili.
- Tema chiaro/scuro commutabile a runtime, con i colori del log adattati al tema.
- Tutta la comunicazione gira in un thread worker: la GUI non si blocca mai, nemmeno sui timeout.
Il PC si collega alla scheda tramite un bridge USB-UART CP2102N con transceiver RS-485 THVD1424. La direzione half-duplex (DE/RE) è gestita dall'hardware del CP2102N (modalità RS-485 con RTS automatico): il software non controlla l'RTS. La porta viene trattata come una normale porta COM.
Per provare con hardware reale: collega la scheda (CP2102N), premi Refresh, seleziona la porta, imposta baudrate/parità coerenti col dispositivo, connetti e leggi/scrivi.