RS232-Verbindungen (serielle Schnittstelle) mittels Software-Konverter auf TCP (Internet) übertragen
  • Go 97%
  • Shell 2.5%
  • PowerShell 0.4%
  • Batchfile 0.1%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
Dieter Lang b7c92b58c7
All checks were successful
Go CI / build (push) Successful in 1h6m48s
CI-Build - altes Development-Release immer löschen
2026-09-16 12:46:10 +02:00
.forgejo/workflows CI-Build - altes Development-Release immer löschen 2026-09-16 12:46:10 +02:00
cmd Serverinformationen und Audio-Startkonfiguration anpassen 2026-09-06 11:26:31 +02:00
configs Aktivitätssteuerung in Client-GUI integrieren 2026-09-06 20:29:03 +02:00
internal Activity-Status bei neuer Session an bestehende Clients senden 2026-09-09 16:49:25 +02:00
scripts Release-Erstellung in CI integrieren 2026-09-05 13:55:40 +02:00
.gitignore Deploy-Prozess für Linux und Windows ergänzen 2026-08-26 11:47:07 +02:00
CHANGELOG.md Dokumentation für Version 0.0.14 ergänzen 2026-09-09 17:46:44 +02:00
go.mod Audio-Infrastruktur und Runtime-Integration ergänzen 2026-09-05 11:23:44 +02:00
go.sum Audio-Infrastruktur und Runtime-Integration ergänzen 2026-09-05 11:23:44 +02:00
Icon.png Build-Prozess für Linux und Windows automatisieren 2026-08-26 11:41:31 +02:00
LICENSE Initial commit 2026-08-09 17:55:34 +02:00
README.md Dokumentation für Version 0.0.14 ergänzen 2026-09-09 17:46:44 +02:00

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 SessionID wird 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.json definierter, lokal nicht vorhandener Port
  • ein lokal vorhandener, aber nicht in client.json definierter 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:

  1. Einen freien Port aus dem konfigurierten Bereich auswählen.
  2. Den öffentlichen /dev/ttyUSBxxx-Symlink einmalig anlegen.
  3. Den Port in client.json eintragen.
  4. Den Client starten.
  5. 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:

  1. rs2322tcp-pty-test als simuliertes Rotorgerät
  2. rs2322tcp-server mit configs/server-test.json
  3. rs2322tcp-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:

  1. erzeugt /opt/rs2322tcp
  2. installiert den Server nach /opt/rs2322tcp/rs2322tcp-server
  3. erzeugt /etc/rs2322tcp
  4. installiert die Standardkonfiguration nach /etc/rs2322tcp/server.json
  5. installiert die Systemd-Service-Datei
  6. führt systemctl daemon-reload aus
  7. aktiviert den Dienst
  8. 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:

  1. stoppt den Dienst, sofern er läuft
  2. deaktiviert den automatischen Start
  3. entfernt die Systemd-Service-Datei
  4. lädt Systemd neu
  5. entfernt /opt/rs2322tcp
  6. 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 Buildsystem
  • v0.0.2 – Client-Control- und Data-Verbindungen
  • v0.0.3 – Linux-PTY-Unterstützung und Geräte-Simulator
  • v0.0.4 – interaktive TX-Funktion des Geräte-Simulators
  • v0.0.5 – konfigurierbare lokale virtuelle serielle Ports
  • v0.0.6 – Client-Runtime und Serial-Bridge
  • v0.0.7 – Geräteerkennung und grafische Gerätezuordnung
  • v0.0.8 – Validierung der virtuellen Ports und Überarbeitung der Client-GUI
  • v0.0.9 – Windows-Unterstützung und plattformabhängige virtuelle Ports
  • v0.0.10 – Korrekturen der Portverwaltung und Startbytes
  • v0.0.11 – Windows-Client mit funktionierender Fyne-GUI und Rotor-Startcode
  • v0.0.12 – Kommunikationsanzeige in der GUI sowie Server-Installations- und Deinstallationspakete
  • v0.0.13 – automatische Erzeugung von Distributionspaketen in der CI und automatische Forgejo-Releases bei Versions-Tags
  • v0.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