- Go 97%
- Shell 2.5%
- PowerShell 0.4%
- Batchfile 0.1%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
|
|
||
| .forgejo/workflows | ||
| cmd | ||
| configs | ||
| internal | ||
| scripts | ||
| .gitignore | ||
| CHANGELOG.md | ||
| go.mod | ||
| go.sum | ||
| Icon.png | ||
| LICENSE | ||
| README.md | ||
rs2322tcp
rs2322tcp ermöglicht die transparente Übertragung von RS232-Daten über
TCP/IP.
Das Projekt ist für den Einsatz geeignet, bei dem eine vorhandene Software eine serielle Schnittstelle erwartet, das zugehörige Gerät sich jedoch an einem entfernten Standort befindet.
Ziel
Auf der Client-Seite soll vorhandene Hersteller-Software eine normale serielle Schnittstelle vorfinden.
Die Daten werden vom rs2322tcp-client über TCP an einen entfernten
rs2322tcp-server übertragen. Der Server verbindet die Netzwerkverbindung mit
einer realen seriellen Schnittstelle.
Damit sollen weder die vorhandene Software auf dem Client noch die angeschlossenen Geräte auf der Remote-Seite erkennen müssen, dass die Verbindung über ein Netzwerk erfolgt.
Typische Anwendungen sind beispielsweise:
- Funkgeräte mit CAT-Steuerung
- Antennenrotoren mit herstellerspezifischen seriellen Protokollen
- andere Geräte, die über RS232 gesteuert werden
Architektur
Client-PC Raspberry Pi 5
───────────────── ─────────────────
Hersteller-Software rs2322tcp-server
│ │
│ virtuelle │
│ serielle Schnittstelle │
▼ │
rs2322tcp-client │
│ │
└──────────── TCP/IP ──────────────────┘
│
┌──────────┴──────────┐
│ │
USB-to-RS232 USB-to-RS232
│ │
Funkgerät Rotor
Aktueller Datenpfad
Der serverseitige TCP-/RS232-Datenpfad ist implementiert.
TCP-Control
│
▼
Session
│
├── Gerät 1 ──► dynamischer Data-Port
│ │
│ ▼
│ TCP Data
│ │
│ ▼
│ Serial Layer
│ │
│ ▼
│ RS232
│
└── Gerät 2 ──► dynamischer Data-Port
Die serielle Schnittstelle wird erst geöffnet, wenn ein Client tatsächlich eine Data-Verbindung zum entsprechenden dynamischen TCP-Port aufbaut.
Pro konfiguriertem Gerät ist nur eine aktive Data-Verbindung vorgesehen.
Die Datenübertragung erfolgt bidirektional:
TCP ───────────────► RS232
TCP ◄────────────── RS232
Auch der Client-Datenpfad ist implementiert:
Virtueller serieller Port
│
▼
rs2322tcp-client
│
│ TCP-Control
▼
Session
│
│ TCP-Data
▼
rs2322tcp-server
│
▼
reale serielle
Schnittstelle
│
▼
Gerät
Der Client kann mehrere konfigurierte virtuelle serielle Schnittstellen gleichzeitig verwalten.
Client
Der Client kann unter folgenden Betriebssystemen eingesetzt werden:
- Linux
- Windows
Die gemeinsame Client-Logik ist von der plattformspezifischen Bereitstellung der virtuellen seriellen Schnittstelle getrennt.
Der Client besteht im Wesentlichen aus:
- Control-Verbindung zum Server
- Verwaltung der vom Server angebotenen Geräte
- Runtime zur Verwaltung mehrerer virtueller Ports
- virtuellen seriellen Schnittstellen
- TCP-Data-Connections
- bidirektionalen Bridges zwischen virtuellem Port und TCP-Verbindung
- grafischer Benutzeroberfläche
- Kommunikationsanzeige für den laufenden Datenverkehr
Linux
Unter Linux ist die virtuelle serielle Schnittstelle über einen direkt aus Go erzeugten PTY implementiert.
Die Implementierung verwendet /dev/ptmx und stellt den zugehörigen PTY-Slave
unter /dev/pts/N bereit.
Die PTY-Schnittstelle wird im Raw Mode betrieben. Dadurch werden die übertragenen Daten als transparenter Byte-Strom behandelt.
Die allgemeine Client-Logik verwendet dafür die Abstraktion VirtualSerial.
Die Linux-spezifische Implementierung ist von dieser Abstraktion getrennt.
Für die PTY-Funktion ist keine externe Laufzeitabhängigkeit wie socat
erforderlich.
Windows
Unter Windows wird dieselbe gemeinsame Client- und Konfigurationslogik verwendet. Für Tests und den Betrieb können vorhandene virtuelle COM-Port-Verbindungen verwendet werden.
Mit Version v0.0.11 wurde der Windows-Client mit funktionierender Fyne-GUI
sowie der automatischen Übertragung der konfigurierten Rotor-Startbytes praktisch
getestet.
Der vollständige Datenweg über einen virtuellen Windows-COM-Port, TCP und einen Raspberry-Pi-Server mit realem SPID Rot2Prog wurde bidirektional erfolgreich getestet.
Kommunikationsanzeige in der Client-GUI
Die grafische Client-Oberfläche enthält eine Kommunikationsanzeige für den laufenden Datenverkehr.
Die Bridge schreibt die übertragenen Daten in einen gemeinsamen, nebenläufigkeitssicher verwalteten Kommunikationsspeicher. Die GUI liest diese Einträge regelmäßig und zeigt sie an.
Damit bleibt die Architektur bewusst einfach:
Bridge
│
├── TX ──┐
│ │
└── RX ──┤
▼
gemeinsamer Kommunikationsspeicher
│
▼
GUI
Die Anzeige ist auf die letzten zehn Kommunikationszeilen begrenzt, damit sie übersichtlich bleibt.
Die Richtungsangaben beziehen sich immer auf den rs2322tcp-client:
TX = Daten vom Client zum Server beziehungsweise Remote-Gerät
RX = Daten vom Server beziehungsweise Remote-Gerät zum Client
Eine Zeile enthält:
- Übertragungsrichtung
- die übertragenen Bytes in hexadezimaler Darstellung
- eine Textdarstellung der Bytes ähnlich einem Hex-Editor
Beispiel:
TX 57 00 00 00 00 00 00 00 00 00 00 1F 20 W...........
RX 57 07 01 06 00 01 03 06 02 00 01 20 W..........
Nicht druckbare Zeichen werden in der Textdarstellung durch einen Punkt ersetzt.
Die Kommunikationsanzeige dient ausschließlich der Diagnose. Sie verändert den Datenstrom nicht.
Auch die automatisch übertragenen startup_bytes werden als TX in der Anzeige
sichtbar, sofern die Übertragung über die normale Client-Bridge erfolgt.
Server
Der Server ist insbesondere für den Betrieb auf einem Raspberry Pi vorgesehen.
Mehrere USB-to-RS232-Adapter können angeschlossen werden. Anzahl, Bezeichnung und serielle Parameter der Anschlüsse werden über eine Konfigurationsdatei festgelegt.
Die serverseitige Serial-Kommunikation verwendet go.bug.st/serial.
Serielle Schnittstelle
Für die Ansteuerung der seriellen Schnittstellen wird derzeit verwendet:
go.bug.st/serial v1.7.1
Die verwendete Bibliothek wurde zusätzlich auf dem privaten Git-Server des Projektes gespiegelt, um bei einem Ausfall des ursprünglichen Anbieters weiterhin auf den verwendeten Quellstand zugreifen zu können.
Die verwendete Version v1.7.1 ist auf dem Backup-Repository einschließlich
Git-Tag vorhanden.
Netzwerk
Für die Übertragung der RS232-Daten wird TCP verwendet.
Die beteiligten Systeme können über ein vertrauenswürdiges Tailscale-Netz verbunden werden.
Eine zusätzliche TLS-Verschlüsselung ist deshalb für den derzeitigen Anwendungsfall nicht vorgesehen.
Audioübertragung
rs2322tcp enthält inzwischen zusätzlich zur seriellen Datenübertragung eine
Audio-Infrastruktur für die Sprachübertragung zwischen den Clients.
Die Audioübertragung ist bewusst von der seriellen Schnittstellenlogik und von GPIO-/PTT-Funktionen getrennt.
Der aktuelle Audio-Datenweg verwendet:
PCM
│
▼
Opus
│
▼
RTP
│
▼
UDP
│
▼
AudioRouter
│
├────────► Client A
│
├────────► Client B
│
└────────► weitere Clients
Für den Audiotransport werden verwendet:
Opus: github.com/pion/opus
RTP: github.com/pion/rtp
Audio: github.com/gen2brain/malgo
Das interne Audioformat ist:
Samplerate: 16000 Hz
Kanäle: 1 (Mono)
Sampletyp: 16 Bit Signed PCM
Frame: 20 ms
Samples: 320
PCM-Daten: 640 Byte pro Frame
RTP verwendet eine Clock-Rate von 48000 Hz und die für Opus vorgesehene Payload
Type 111. Die RTP-Zeitstempel werden passend zum 20-ms-Audioframe fortgeführt.
Client-Audio
Der Client stellt zwei lokale Richtungen bereit:
Mikrofon
│
▼
LocalAudio Input
│
▼
PCMFrameReader
│
▼
Opus / RTP / UDP
│
▼
Server
und:
Server
│
▼
UDP / RTP
│
▼
Opus
│
▼
LocalAudio Output
│
▼
Kopfhörer / Lautsprecher
Die lokale Audio-Hardware wird über malgo angesprochen. Ohne explizite
Geräteauswahl wird das vom Betriebssystem bereitgestellte Standard-Eingabe-
beziehungsweise Standard-Ausgabegerät verwendet.
Für den normalen Anwender ist deshalb keine zusätzliche Audio-Software erforderlich.
Audio-Konfiguration
Audio wird in der Client-Konfiguration optional aktiviert:
{
"audio": {
"enabled": true,
"input": {
"device": ""
},
"output": {
"device": ""
}
}
}
Leere Geräteangaben bedeuten die Verwendung der jeweiligen Betriebssystem-Standardgeräte.
Die Audio-Konfiguration ist optional. Ist audio.enabled nicht gesetzt oder
false, wird keine lokale Audio-Runtime gestartet.
Die Server-Konfiguration besitzt ebenfalls einen Audio-Bereich:
{
"audio": {
"enabled": true,
"input": {
"device": ""
},
"output": {
"device": ""
}
}
}
Die serverseitige Audio-Hardwareanbindung ist derzeit noch nicht der produktive Radio-Audioweg. Die aktuelle Server-Audiofunktion stellt den Netzwerkweg, Sessions und das Routing bereit. Die eigentliche Anbindung der Radio-RX-/TX-Audiogeräte folgt als eigener Entwicklungsschritt.
Der Netzwerk-Audioweg wurde zusätzlich praktisch mit einem Windows-11-Client und einem Linux-Client beziehungsweise Raspberry-Pi-Server geprüft. Dabei funktionierten sowohl die Audioausgabe als auch die Mikrofonübertragung über die UDP/RTP-Strecke.
Audio-Sessions
Für Audio wird zusätzlich zur TCP-Control-Verbindung eine UDP-Session aufgebaut.
Der Client stellt dabei einen lokalen UDP-Empfangsport bereit und erhält vom Server die für die Audio-Session benötigten Portinformationen.
Die eigentliche Audioübertragung erfolgt anschließend als RTP/UDP.
Activity und PTT
Die Aktivitätsverwaltung ist vom Audio-Datenstrom getrennt.
Es gilt:
- Zu jedem Server kann genau ein Client aktiv sein.
- Alle weiteren verbundenen Clients bleiben als Listener empfangsbereit.
- Listener dürfen Audio empfangen, aber kein Audio senden.
- Nur der aktive Client darf Audio senden.
- Ein Client wird nicht automatisch aktiv, wenn ein anderer Client aktiv ist.
- Eine Aktivitätsübernahme erfolgt nicht automatisch.
- Der aktive Client muss seine Aktivität ausdrücklich freigeben.
- Beim Trennen des aktiven Clients wird die Aktivität serverseitig freigegeben.
- Der aktuelle aktive
SessionIDwird an alle Clients verteilt. - Beim Verbinden einer neuen Session wird der aktuelle Activity-Status zusätzlich an die bereits verbundenen Clients gesendet.
- Dadurch aktualisieren bereits verbundene Clients ihre Aktivitätsanzeige sofort, ohne dass eine erneute Verbindung erforderlich ist.
- Ein später eintreffender PTT-Status führt nicht zu einem Wechsel der aktiven Session.
Der Server erzwingt die TX-Regel serverseitig. Audio eines aktiven Clients wird vom Server an die verbundenen Audio-Empfänger verteilt.
Die SessionID wird vom Server vergeben und dient dem Client zur Prüfung, ob
die eigene Session aktuell aktiv ist.
Die Aktivität ist ein Laufzeitstatus und wird nicht in der JSON-Konfiguration gespeichert.
Audio-Routing
Der Server verwendet für die Audioverteilung einen gemeinsamen
RXBroadcaster.
Der aktuelle Client-TX-Weg ist:
aktiver Client
│
▼
Opus / RTP / UDP
│
▼
Server AudioSession
│
▼
AudioRouter
│
├──► Client 1
├──► Client 2
├──► Client 3
└──► ...
Nicht aktive Clients können die Audioübertragung empfangen, dürfen aber selbst keinen TX-Audiostrom zum Server senden.
Der AudioRouter kann zusätzlich einen später anzuschließenden Radio-TX-Pfad aufnehmen. Die konkrete Radio-Hardware ist derzeit noch nicht angebunden.
Ende-zu-Ende-Audiotest
Für die Entwicklung steht ein lokaler Sprachtest unter:
cmd/rs2322tcp-audio-local-test
zur Verfügung.
Dabei werden ein lokaler rs2322tcp-server und zwei Client-Runtimes gestartet.
Der Testweg ist:
Standard-Mikrofon
│
▼
Client A Runtime
│
▼
PCM → Opus → RTP/UDP
│
▼
lokaler rs2322tcp-Server
│
▼
RTP/UDP → Opus → PCM
│
▼
Client B Runtime
│
▼
Standard-Kopfhörer
Der Test wird mit:
go run ./cmd/rs2322tcp-audio-local-test
gestartet.
Der Test verwendet keine Audio-Hardware des Servers.
Der vollständige Weg über Runtime, Opus, RTP, UDP, Server-Routing und die
lokalen Standard-Audiogeräte wurde erfolgreich geprüft. Die eigene Stimme
wurde dabei auf dem Kopfhörer hörbar zurückgegeben.
Zusätzlich existiert:
cmd/rs2322tcp-audio-test
für den lokalen direkten Audio-Hardwaretest ohne Client-/Server-Netzwerkweg.
Der direkte Test verwendet ebenfalls Standard-Mikrofon und Standard-Ausgabegerät und dient zur Prüfung der lokalen Audioaufnahme und Audioausgabe.
Konfiguration
Client und Server werden jeweils über JSON-Konfigurationsdateien konfiguriert.
Client-Konfiguration
Eine Client-Konfiguration enthält insbesondere:
- Server-Adresse und Port
- den reservierten Bereich virtueller Ports
- die vorhandenen virtuellen Schnittstellen
- die Zuordnung eines virtuellen Ports zu einem Remote-Gerät
- optional zu übertragende
startup_bytes
Beispiel:
{
"server": {
"address": "127.0.0.1",
"port": 5000
},
"virtual_port_range": {
"first": 100,
"last": 199
},
"virtual_ports": [
{
"port": "/dev/ttyUSB100",
"remote_device": "rotor",
"startup_bytes": "57 00 00 00 00 00 00 00 00 00 00 1F 20"
}
]
}
Ein leerer Wert für remote_device kennzeichnet eine vorhandene, aber derzeit
nicht mit einem Remote-Gerät verbundene virtuelle Schnittstelle.
Gerätezuordnung
Die vom Server angebotenen Geräte können über die grafische Benutzeroberfläche virtuellen Schnittstellen zugeordnet werden.
Dabei gelten folgende Regeln:
- Eine virtuelle Schnittstelle kann nur einem Gerät zugeordnet werden.
- Ein Gerät kann nicht gleichzeitig mehreren virtuellen Schnittstellen zugeordnet werden.
- Freie virtuelle Schnittstellen können dem Zustand „nicht verbunden“ entsprechen.
- Änderungen werden zunächst im Arbeitsspeicher gehalten.
- Beim Schließen des Gerätezuordnungsfensters werden die Änderungen in der Client-Konfiguration gespeichert.
- Beim Schließen des Hauptfensters werden ungespeicherte Änderungen erkannt.
Startbytes
Für einen virtuellen Port können startup_bytes konfiguriert werden.
Diese Bytes werden nach erfolgreichem Verbindungsaufbau automatisch an das zugeordnete Remote-Gerät übertragen.
Damit kann beispielsweise eine beim Start benötigte Rotor-Anfrage automatisch gesendet werden.
Prüfung der virtuellen Ports
Beim Start des Clients werden die konfigurierten virtuellen Ports mit den tatsächlich vorhandenen lokalen Schnittstellen abgeglichen.
Unter Linux werden dabei insbesondere die öffentlichen symbolischen Links geprüft.
Erkannt werden:
- ein in
client.jsondefinierter, lokal nicht vorhandener Port - ein lokal vorhandener, aber nicht in
client.jsondefinierter Port
Bei einer Abweichung wird der Start abgebrochen und ein verständlicher Fehlerdialog angezeigt.
Der Client legt die öffentlichen /dev-Links nicht automatisch an und benötigt
für diese Prüfung keine Root-Rechte.
Manuelle Einrichtung virtueller Ports unter Linux
Die öffentlichen virtuellen Ports werden einmalig eingerichtet.
Zunächst wird das Verzeichnis für die internen Links angelegt:
mkdir -p ~/.rs2322tcp/virtual
Anschließend werden die öffentlichen Links einmalig mit administrativen Rechten angelegt:
sudo ln -s "$HOME/.rs2322tcp/virtual/ttyUSB100" /dev/ttyUSB100
sudo ln -s "$HOME/.rs2322tcp/virtual/ttyUSB101" /dev/ttyUSB101
Die Zuordnung ist:
/dev/ttyUSB100 -> ~/.rs2322tcp/virtual/ttyUSB100 -> PTY
/dev/ttyUSB101 -> ~/.rs2322tcp/virtual/ttyUSB101 -> PTY
Die äußeren Links unter /dev gehören dabei root. Das ist beabsichtigt.
Der Client selbst läuft anschließend als normaler Benutzer.
Die internen Links unter:
~/.rs2322tcp/virtual/
werden vom Client auf die jeweils verwendeten PTYs gesetzt.
Die Einrichtung eines neuen virtuellen Ports besteht daher aus:
- Einen freien Port aus dem konfigurierten Bereich auswählen.
- Den öffentlichen
/dev/ttyUSBxxx-Symlink einmalig anlegen. - Den Port in
client.jsoneintragen. - Den Client starten.
- Die Gerätezuordnung gegebenenfalls über die GUI vornehmen.
Der Client prüft beim Start, ob Konfiguration und vorhandene Symlinks übereinstimmen.
Virtuelle serielle Schnittstelle unter Linux
Für den Linux-Client wird die virtuelle serielle Schnittstelle direkt über den Linux-PTY-Mechanismus erzeugt.
Dabei entsteht ein PTY-Paar:
/dev/ptmx
│
▼
PTY Master
│
↕
PTY Slave
│
▼
/dev/pts/N
Der PTY-Slave wird über den vom Anwender eingerichteten virtuellen
/dev/ttyUSBxxx-Symlink erreichbar.
Der rs2322tcp-client verwendet den PTY-Master und transportiert die Bytes
über TCP zum Server.
Die PTY-Implementierung arbeitet im Raw Mode und wurde mit einem vollständigen
Bytebereich von 0x00 bis 0xFF geprüft.
Dabei wurde die bidirektionale Übertragung aller 256 möglichen Bytewerte erfolgreich getestet.
Vollständiger Simulationsaufbau auf einem Ubuntu-PC
Der komplette Datenweg kann für Entwicklung und Tests auf einem einzigen Ubuntu-PC ausgeführt werden. Dazu laufen gleichzeitig drei Programme:
rs2322tcp-pty-testals simuliertes Rotorgerätrs2322tcp-servermitconfigs/server-test.jsonrs2322tcp-client
Der Datenweg ist:
Testprogramm oder Hersteller-Software
│
▼
/dev/ttyUSB100
│
▼
rs2322tcp-client
│ TCP
▼
rs2322tcp-server
│
▼
/dev/pts/N
│
▼
rs2322tcp-pty-test
simuliertes Rotorgerät
1. PTY-Simulator starten
In einem ersten Terminal:
cd ~/rs2322tcp
go run ./cmd/rs2322tcp-pty-test
Beispiel:
rs2322tcp-pty-test
Port: /dev/pts/1
Modus: Rotor-Simulation mit Echo-Fallback
Warte auf Daten ...
Der ausgegebene PTY-Pfad wird im nächsten Schritt benötigt.
Der Simulator hält Master und Slave während seiner gesamten Laufzeit geöffnet. Bei der bekannten Rotor-Anfrage wird automatisch die konfigurierte Rotor-Antwort gesendet. Alle anderen Daten werden als Echo zurückgegeben.
2. Testkonfiguration des Servers anpassen
In configs/server-test.json wird der Rotor auf den aktuell vom Simulator
ausgegebenen PTY-Slave gesetzt.
Beispiel:
{
"id": "rotor",
"name": "Antennenrotor",
"serial_port": "/dev/pts/1",
"baud_rate": 600,
"data_bits": 8,
"parity": "none",
"stop_bits": 1
}
Die PTY-Nummer ist nicht dauerhaft fest. Nach jedem neuen Start des
PTY-Simulators muss der tatsächlich ausgegebene /dev/pts/N-Pfad geprüft und
gegebenenfalls manuell in server-test.json eingetragen werden.
Im Echtbetrieb wird hier wieder ein fester Hardware-Port verwendet, zum Beispiel:
/dev/ttyUSB0
3. Server starten
In einem zweiten Terminal:
cd ~/rs2322tcp
go run ./cmd/rs2322tcp-server -config ./configs/server-test.json
4. Server-Monitor als Sniffer
Ist in der Server-Konfiguration
"serial_monitor": true
gesetzt, protokolliert der Server den übertragenen Datenverkehr.
Im Simulationsaufbau werden dadurch unter anderem die Richtungen
TCP RX
SERIAL TX
SERIAL RX
TCP TX
sichtbar.
Ein typischer Ablauf ist:
TCP RX 57 00 00 00 00 00 00 00 00 00 00 1F 20
SERIAL TX 57 00 00 00 00 00 00 00 00 00 00 1F 20
SERIAL RX 57 07 01 06 00 01 03 06 02 00 01 20
TCP TX 57 07 01 06 00 01 03 06 02 00 01 20
Der Server arbeitet damit gleichzeitig als Monitor beziehungsweise Sniffer für den übertragenen seriellen Datenverkehr.
5. Client-Konfiguration für den lokalen Test
Für den lokalen Test kann configs/client.json beispielsweise so aussehen:
{
"server": {
"address": "127.0.0.1",
"port": 5000
},
"virtual_port_range": {
"first": 100,
"last": 199
},
"virtual_ports": [
{
"port": "/dev/ttyUSB100",
"remote_device": "rotor",
"startup_bytes": "57 00 00 00 00 00 00 00 00 00 00 1F 20"
}
]
}
Der öffentliche virtuelle Port /dev/ttyUSB100 muss vorher einmalig
eingerichtet worden sein.
6. Client starten
In einem dritten Terminal:
cd ~/rs2322tcp
go run ./cmd/rs2322tcp-client
Nach erfolgreichem Verbindungsaufbau werden die konfigurierten startup_bytes
automatisch zum zugeordneten Rotor übertragen.
Der Server-Monitor zeigt dann den vollständigen Ablauf:
TCP RX -> SERIAL TX -> SERIAL RX -> TCP TX
Zusätzlich zeigt die Client-GUI die aus Client-Sicht übertragenen TX- und RX-Daten in ihrer Kommunikationsanzeige.
Damit ist der gesamte Datenweg vom virtuellen Client-Port über TCP zum simulierten Rotor und wieder zurück prüfbar.
7. Virtuellen Port direkt testen
Eine Antwort kann beispielsweise mit
cat /dev/ttyUSB100 | xxd -g 1
beobachtet werden.
In einem zweiten Terminal kann eine Rotor-Anfrage gesendet werden:
printf '\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x20' > /dev/ttyUSB100
Der Rückweg erfolgt über denselben vollständigen Datenpfad zurück zu
/dev/ttyUSB100.
Hinweis zu /dev/pts/N
/dev/pts/N wird in diesem Aufbau ausschließlich als temporärer Test-Port für
den PTY-Simulator verwendet. Die Nummer ist nicht dauerhaft und kann sich nach
einem Neustart des Simulators ändern.
Im produktiven Betrieb sind die serverseitigen Geräte dagegen echte, fest angeschlossene Hardware-Schnittstellen, beispielsweise:
/dev/ttyUSB0
/dev/ttyUSB1
/dev/ttyUSB3
Diagnose und Logging
Für Debugging und Diagnose stehen mehrere Möglichkeiten zur Verfügung.
Serverseitig kann serial_monitor aktiviert werden. Damit werden die
Richtungen zwischen TCP und RS232 protokolliert.
Clientseitig steht die Kommunikationsanzeige der GUI zur Verfügung. Sie zeigt den Datenverkehr aus Sicht des Clients:
TX = Client -> Server / Remote-Gerät
RX = Server / Remote-Gerät -> Client
Die Daten werden sowohl hexadezimal als auch als Textdarstellung angezeigt.
Für die Linux-PTY-Funktion und den beschriebenen Simulationsaufbau wird
rs2322tcp ohne socat betrieben. Die benötigten PTYs werden direkt aus Go
erzeugt.
Geräte-Simulator
Das Programm rs2322tcp-device-sim dient als Simulator für ein an einer
seriellen Schnittstelle angeschlossenes Gerät.
Der Simulator kann:
- Daten von einer seriellen Schnittstelle oder einem Linux-PTY empfangen
- empfangene Rohdaten als Hexdump anzeigen
- beliebige Bytefolgen über eine interaktive Hex-Eingabe senden
- ungültige Hex-Eingaben erkennen
- als virtuelle serielle Gegenstelle für externe Software dienen
Beispiel:
go run ./cmd/rs2322tcp-device-sim -port /dev/pts/7
Die Hex-Eingabe kann beispielsweise mit oder ohne Leerzeichen erfolgen:
TX> 46 41 00 10 0D
TX> 464100100D
Der Simulator interpretiert die seriellen Daten nicht. Die Darstellung erfolgt als Rohdaten.
Sniffer-Funktion
Der Empfänger des Testaufbaus kann gleichzeitig als einfacher Sniffer verwendet werden.
Dadurch kann beobachtet werden, welche Kommandos externe Software tatsächlich über die serielle Schnittstelle versendet.
Der Sniffer verändert die empfangenen Daten nicht, sondern zeigt die empfangenen Bytes lediglich an.
Hardwaretest mit SPID Rot2Prog
Für den praktischen Hardwaretest wurde ein SPID Rot2Prog als Antennenrotor über einen FT232R USB-to-RS232-Adapter angeschlossen.
Unter Linux wurde der Adapter als
/dev/ttyUSB0
erkannt.
Der Rot2Prog verwendet für die RS232-Kommunikation:
600 Baud
8 Datenbits
keine Parität
1 Stopbit
also:
600 8N1
Rotor einschalten
Vor dem Kommunikationstest muss der SPID-Rot2Prog eingeschaltet sein.
Der Controller muss für die serielle Steuerung im SPID-/Auto-Betrieb betrieben werden.
Direkter Hardwaretest
Der serielle Port kann zunächst unabhängig von rs2322tcp getestet werden:
stty -F /dev/ttyUSB0 600 cs8 -cstopb -parenb raw -echo
Kontrolle:
stty -F /dev/ttyUSB0
Anschließend kann die serielle Antwort des Controllers beobachtet werden:
cat /dev/ttyUSB0 | xxd -g 1
Eine Statusabfrage kann beispielsweise mit folgendem Paket gesendet werden:
printf '\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x20' > /dev/ttyUSB0
Bei erfolgreicher Kommunikation antwortet der Rot2Prog mit einem 12-Byte-Datenpaket.
Test über rs2322tcp
Nach erfolgreichem direkten Hardwaretest wird der reale serielle Port im Server konfiguriert:
Rotor:
/dev/ttyUSB0
600 Baud
8 Datenbits
keine Parität
1 Stopbit
Der Client stellt dem Anwender dafür beispielsweise den virtuellen Port
/dev/ttyUSB101
zur Verfügung.
Die gleiche Statusabfrage kann anschließend über den vollständigen rs2322tcp-Datenpfad gesendet werden.
Der praktische Hardwaretest hat gezeigt, dass die Antwort des Rot2Prog vollständig über den Datenweg
virtueller Port
-> rs2322tcp-client
-> TCP
-> rs2322tcp-server
-> RS232
-> Rot2Prog
-> RS232
-> rs2322tcp-server
-> TCP
-> rs2322tcp-client
-> virtueller Port
zurück übertragen wird.
Eine praktisch beobachtete Antwort war:
57 07 01 06 00 01 03 06 02 00 01 20
Externe USB-to-Seriell-Adapter
Für den praktischen Einsatz sind USB-to-Seriell-Adapter vorgesehen.
Unter Linux werden solche Adapter normalerweise als serielle Gerätedateien bereitgestellt, beispielsweise:
/dev/ttyUSB0
Das Projekt benötigt für die serielle Kommunikation keine direkte
libusb-Anbindung. Bei üblichen USB-to-Seriell-Adaptern wird die serielle
Schnittstelle über den Linux-Kernel-Treiber bereitgestellt.
Eine spezielle Hardware-Anbindung über libusb ist für rs2322tcp daher nicht
vorgesehen.
Installation des Servers unter Linux
Für den Linux-Server werden mit deploy.sh vollständige Serverpakete erzeugt.
Aktuell werden Serverpakete für folgende Architekturen erstellt:
- Linux amd64
- Linux arm64
- Linux 386
- Linux arm
Ein Serverpaket enthält:
rs2322tcp-server
server.json
install.sh
uninstall.sh
rs2322tcp-server.service
Installation
Das passende Paket auf das Zielsystem kopieren und entpacken:
tar -xzf rs2322tcp-server-<VERSION>.tar.gz
cd rs2322tcp-server
Anschließend:
sudo ./install.sh
Das Installationsskript:
- erzeugt
/opt/rs2322tcp - installiert den Server nach
/opt/rs2322tcp/rs2322tcp-server - erzeugt
/etc/rs2322tcp - installiert die Standardkonfiguration nach
/etc/rs2322tcp/server.json - installiert die Systemd-Service-Datei
- führt
systemctl daemon-reloadaus - aktiviert den Dienst
- startet den Dienst
Die verwendeten Pfade sind:
Programm:
/opt/rs2322tcp/rs2322tcp-server
Konfiguration:
/etc/rs2322tcp/server.json
Systemd-Service:
/etc/systemd/system/rs2322tcp-server.service
Den Status prüfen:
systemctl status rs2322tcp-server
Logeinträge anzeigen:
sudo journalctl -u rs2322tcp-server -n 50 --no-pager
Laufende Loganzeige:
sudo journalctl -u rs2322tcp-server -f
Deinstallation
Die vollständige Deinstallation erfolgt mit:
sudo ./uninstall.sh
Das Skript:
- stoppt den Dienst, sofern er läuft
- deaktiviert den automatischen Start
- entfernt die Systemd-Service-Datei
- lädt Systemd neu
- entfernt
/opt/rs2322tcp - entfernt
/etc/rs2322tcp
Die Konfiguration wird bewusst ohne zusätzliche Rückfrage entfernt, da sie nur die projektspezifische Server-Konfiguration enthält und die Deinstallation vollständig sein soll.
Tests
Die wichtigsten Komponenten verfügen über automatisierte Tests.
Der aktuelle Stand wird unter anderem mit folgenden Befehlen geprüft:
go test ./...
und:
go test -race ./...
Der Race Detector wird eingesetzt, um Probleme bei der nebenläufigen Verarbeitung von Sessions, Data-Listenern, DataConnections, Bridges und Client-Komponenten zu erkennen.
Die Linux-PTY-Komponente wurde mit einem vollständigen Bytebereich von
0x00 bis 0xFF geprüft.
Die Verwaltung der virtuellen Ports verfügt über Tests für:
- automatische Portreservierung
- gezielte Reservierung einer konfigurierten Portnummer
- Freigabe virtueller Ports
- Erstellung und Entfernung der internen PTY-Links
- Abgleich vorhandener virtueller Ports mit der Client-Konfiguration
Die Gerätezuordnung verfügt über Tests für:
- Zuordnung von Geräten zu virtuellen Ports
- Freigabe virtueller Ports
- Vermeidung doppelter Zuordnungen
- Speicherung der Konfiguration
- Laden der gespeicherten Zuordnung
Der Geräte-Simulator verfügt zusätzlich über automatisierte Tests für:
- Hex-Konvertierung
- Behandlung ungültiger Eingaben
Die Audio-Komponenten verfügen zusätzlich über automatisierte Tests für:
- PCM-Frame-Aufteilung
- Opus-Kodierung und -Dekodierung
- RTP-Paketierung und RTP-Auswertung
- UDP-Sender und UDP-Empfänger
- Audio-Stream und Audio-Broadcasting
- vollständige Audio-Session im Client
- Ende-zu-Ende-Audioübertragung über Client-Runtime und Server-Routing
Der lokale Runtime-Sprachtest wurde zusätzlich praktisch mit Standard-Mikrofon und Standard-Kopfhörer durchgeführt.
Die aktuelle Kommunikationsanzeige ist über Tests der Client-Komponenten und den vollständigen Go-Testlauf abgesichert.
Für die Prüfung des Arbeitsbaums:
git diff --check
git status
Projektstruktur
rs2322tcp/
├── .forgejo/
│ └── workflows/
│ └── ci.yml
├── cmd/
│ ├── com0com-test/
│ ├── rs2322tcp-audio-local-test/
│ ├── rs2322tcp-audio-test/
│ ├── rs2322tcp-client/
│ ├── rs2322tcp-client-test/
│ ├── rs2322tcp-device-sim/
│ ├── rs2322tcp-pty-test/
│ └── rs2322tcp-server/
├── fyne-cross/
│ └── dist/
├── configs/
│ ├── client.json
│ ├── server.json
│ └── server-test.json
├── internal/
│ ├── client/
│ ├── config/
│ ├── gui/
│ ├── serial/
│ ├── server/
│ ├── transport/
│ └── version/
├── scripts/
│ ├── build.sh
│ └── server/
│ ├── install.sh
│ ├── uninstall.sh
│ └── rs2322tcp-server.service
├── CHANGELOG.md
├── LICENSE
├── README.md
└── go.mod
Build
Zentrale CI-/Cross-Build-Umgebung
Für die Fyne-basierten Client-Builds wird die zentral gepflegte
Cross-Build-Umgebung go-fyne:1.25-ci verwendet.
Der Container stellt die allgemeine Go-/Fyne-Buildumgebung einschließlich
fyne-cross sowie der für die unterstützten Zielplattformen benötigten
Cross-Compiler bereit. Das Image wird zentral gepflegt und unter
go-fyne:1.25-ci vom Forgejo Runner verwendet.
Projektbezogene Laufzeit- und Entwicklungsabhängigkeiten bleiben davon
getrennt. Die Audioimplementierung verwendet insbesondere malgo; dessen
plattformabhängige Audioanbindung wird über die jeweiligen nativen
Betriebssystem-Schnittstellen bereitgestellt.
Die zentrale Buildumgebung wird damit nicht durch projektspezifische Konfigurationen einzelner Raspberry-Pi-Systeme ersetzt, sondern dient als gemeinsame und reproduzierbare Umgebung für die vorgesehenen Client-Builds.
Der Build erfolgt über:
./scripts/build.sh
Das Build-Skript führt unter anderem folgende Schritte aus:
- Formatierung des Go-Quellcodes
- Ausführung der Tests
- Bereinigung der Go-Module
- Ermittlung der Git-Versionsinformationen
- Build der vorgesehenen Zielplattformen
- Einbettung der Versionsinformationen über den Go-Linker
- Erzeugung von SHA256-Prüfsummen
Aktuell werden folgende Builds erzeugt:
Server
- Linux amd64
- Linux arm64
- Linux 386
- Linux arm
Client
- Linux amd64
- Linux arm64
- Windows amd64
- Windows 386
Zusätzlich wird das eigenständige Programm rs2322tcp-audio-test für die
folgenden Plattformen gebaut:
- Linux amd64
- Linux arm64
- Linux 386
- Linux arm
- Windows amd64
- Windows 386
Die Audio-Test-Binaries werden nicht als eigene Release-Archive veröffentlicht. Für die regulären Client-Plattformen werden sie in die jeweiligen Client-Pakete aufgenommen:
Linux:
rs2322tcp-client
rs2322tcp-audio-test
Windows:
rs2322tcp-client.exe
rs2322tcp-audio-test.exe
Die zusätzliche Audio-Test-Unterstützung für Linux 386 und Linux arm dient ausschließlich der CI-Prüfung und erzeugt keine eigenen Client-Release-Pakete.
Der Server wird CGO-frei direkt mit Go gebaut.
Die Fyne-basierten Client-Pakete werden für Linux und Windows in der
vorgesehenen Fyne-Cross-Build-Umgebung erzeugt. Die daraus entstehenden Client-Archive werden unter fyne-cross/dist/ bereitgestellt
und anschließend direkt von der Forgejo-CI als Release-Artefakte übernommen.
Voraussetzungen für die Fyne-Entwicklung unter Linux
Für den Build der Fyne-GUI unter Linux werden neben Go und GCC die nativen Entwicklungsbibliotheken benötigt, insbesondere:
libgl1-mesa-dev
xorg-dev
libwayland-dev
libxkbcommon-dev
Die Audiofunktion verwendet malgo und wird unter Linux und Windows über die
jeweiligen nativen Audio-Schnittstellen des Betriebssystems angebunden. Für den
Anwender ist deshalb keine zusätzliche Audio-Software wie PipeWire erforderlich;
verwendet werden die vom Betriebssystem bereitgestellten Standardgeräte.
Distributions-Pakete und CI
Die Distributions-Pakete werden vollständig innerhalb der Forgejo-CI erzeugt. Ein separater manueller Paketierungsschritt ist für die Release-Erstellung nicht erforderlich.
Die CI übernimmt aus den bereits erzeugten Build-Artefakten:
- Linux-Server für amd64, arm64, 386 und arm
- Linux-Client für amd64 und arm64
- Windows-Client für amd64 und 386
Für jede Zielplattform werden eindeutig benannte Release-Dateien erzeugt. Die Zielplattform ist Bestandteil des Dateinamens.
Beispiele:
rs2322tcp-server-v0.0.15-linux-amd64.tar.gz
rs2322tcp-server-v0.0.15-linux-arm64.tar.gz
rs2322tcp-client-v0.0.15-linux-amd64.tar.xz
rs2322tcp-client-v0.0.15-windows-amd64.zip
Zu jeder Release-Datei wird zusätzlich eine SHA256-Prüfsumme erzeugt.
Die Linux-Serverpakete enthalten zusätzlich:
rs2322tcp-server
server.json
install.sh
uninstall.sh
rs2322tcp-server.service
Eine separate scripts/deploy.sh-Datei wird dafür nicht benötigt. Paketierung und
Release-Erstellung sind Bestandteil der Forgejo-CI.
CI und automatische Releases
Die Build- und Release-Erstellung erfolgt zusätzlich automatisiert über Forgejo Actions.
Bei einem Push nach main wird der tatsächlich ausgelöste Commit in einem
sauberen Host-Workspace ausgecheckt. Anschließend werden die Tests, die
Server-Builds, die Fyne-Client-Builds und die Distributionspakete erzeugt.
Die CI unterscheidet zwischen normalen main-Builds und Versions-Tags.
Bei einem Push nach main wird zunächst ein eventuell vorhandenes Forgejo
Development Release mit dem festen Tag development gelöscht. Anschließend
wird aus dem aktuellen main-Stand ein neues Development Release erzeugt.
Bei einem Versions-Tag, dessen Name mit v beginnt, wird dagegen ein normales
Forgejo Release für diesen Tag erzeugt.
Der grundsätzliche Ablauf ist:
CI
│
├── Checkout
├── Gofmt
├── Tests
├── go mod tidy prüfen
├── Server-Builds
├── Fyne-Client-Builds
├── Release-Artefakte erzeugen
│ ├── eindeutige Plattformnamen
│ └── SHA256-Prüfsummen
│
├── main
│ └── Development Release
│
└── v*
└── Forgejo Release
Development Releases werden bei jedem erfolgreichen main-Lauf neu erzeugt.
Das vorhandene Development Release wird vorher gelöscht.
Versions-Releases werden nur durch Versions-Tags ausgelöst. Alle erzeugten Archive und die zugehörigen SHA256-Dateien werden als Release-Assets hochgeladen.
Aktueller Entwicklungsstand Audio
Die Audio-Netzwerkstrecke und die Integration in die Client-Runtime sind implementiert und getestet.
Der lokale Ende-zu-Ende-Test mit zwei Client-Runtimes wurde erfolgreich durchgeführt. Dabei wurde die eigene Sprache vom Standard-Mikrofon eines Clients über Opus/RTP/UDP und den lokalen Server zum Standard-Kopfhörer des zweiten Clients übertragen.
Die eigentliche Verbindung des Servers mit einem realen Radio-Audioeingang (RX) beziehungsweise Radio-Audioausgang (TX) ist noch nicht abgeschlossen.
Die Audiofunktion ist deshalb zum aktuellen Arbeitsstand als vorbereitete, funktionierende Netzwerk-/Runtime-Infrastruktur zu betrachten und noch nicht als abgeschlossene Radio-Audio-Gesamtfunktion.
Versionierung
Die Versionierung erfolgt über Git.
Die Git-Informationen werden beim Build in die Binärdateien eingebettet. Neben der Version werden unter anderem Build-Informationen, Commit und Build-Datum erfasst.
Release-Versionen werden über Git-Tags gekennzeichnet.
Aktueller Entwicklungsstand:
v0.0.1– Projektgrundlage und Buildsystemv0.0.2– Client-Control- und Data-Verbindungenv0.0.3– Linux-PTY-Unterstützung und Geräte-Simulatorv0.0.4– interaktive TX-Funktion des Geräte-Simulatorsv0.0.5– konfigurierbare lokale virtuelle serielle Portsv0.0.6– Client-Runtime und Serial-Bridgev0.0.7– Geräteerkennung und grafische Gerätezuordnungv0.0.8– Validierung der virtuellen Ports und Überarbeitung der Client-GUIv0.0.9– Windows-Unterstützung und plattformabhängige virtuelle Portsv0.0.10– Korrekturen der Portverwaltung und Startbytesv0.0.11– Windows-Client mit funktionierender Fyne-GUI und Rotor-Startcodev0.0.12– Kommunikationsanzeige in der GUI sowie Server-Installations- und Deinstallationspaketev0.0.13– automatische Erzeugung von Distributionspaketen in der CI und automatische Forgejo-Releases bei Versions-Tagsv0.0.14– Audio-Infrastruktur, Audio-Sessions, RTP/UDP-Routing, serverseitige Activity-Verwaltung sowie Verteilung des aktuellen Activity-Status an bereits verbundene Clients beim Hinzukommen einer neuen Session
Projektstatus
Das Projekt wird derzeit als funktional weitgehend vollständig betrachtet.
Der implementierte Funktionsumfang umfasst insbesondere:
- transparente bidirektionale Übertragung von RS232-Daten über TCP/IP
- Server-Control-Verbindung und Session-Verwaltung
- dynamische Data-Ports und nebenläufigkeitssichere Data-Listener
- bidirektionale TCP-/RS232-Datenübertragung
- Konfiguration serieller Parameter
- Client-Control-Verbindung und Client-DataConnection
- Client-Runtime zur Verwaltung mehrerer virtueller Ports
- Linux-PTY-Unterstützung im Raw Mode
- gezielte Zuordnung und Verwaltung virtueller Ports
- Windows-COM-Port-Unterstützung
- grafische Gerätezuordnung mit Speicherung in
client.json - Kommunikationsanzeige mit TX/RX, Hex- und Textdarstellung
- Begrenzung der Kommunikationsanzeige auf die letzten zehn Einträge
- Geräte-Simulator mit RX-Hexdump und interaktiver TX-Hex-Eingabe
- automatisierte Tests einschließlich Race Detector
- CGO-freie Server-Builds für mehrere Linux-Architekturen
- Fyne-Client-Pakete für Linux und Windows
- Linux-Serverpakete mit Installation und Deinstallation als Systemd-Dienst
- SHA256-Prüfsummen für die Distributions- und Release-Dateien
- automatisierte Build-, Paket- und Release-Erstellung über Forgejo Actions
- automatische Forgejo-Releases bei Versions-Tags
- optionale Audio-Runtime auf Client-Seite
- lokales Audio über
malgo - Opus-/RTP-/UDP-Audiotransport
- serverseitige Audio-Sessions und Audio-Routing
- serverseitige Activity-Verwaltung mit genau einem aktiven Client
- sofortige Verteilung des Activity-Status an bestehende Clients bei neuer Session
- Ende-zu-Ende-Test der Audioübertragung zwischen zwei Client-Runtimes
- Audio-Hardwaretests auf Linux und Windows mit Standard-Mikrofon und Standard-Ausgabegerät
- vorbereitete serverseitige Anbindung eines späteren Radio-RX-/TX-Audiopfads
Lizenz
GPL-3.0-or-later