# 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

```text
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 Server-Datenpfad

Die serverseitige TCP-/RS232-Verbindung ist inzwischen implementiert:

```text
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:

```text
TCP ───────────────► RS232
TCP ◄────────────── RS232
```

## Client

Der Client soll gleichberechtigt unter folgenden Betriebssystemen eingesetzt werden können:

- Windows
- Linux

Die plattformspezifische Bereitstellung der virtuellen seriellen Schnittstelle wird vom gemeinsamen Client-Kern getrennt.

Die Client-seitige virtuelle serielle Schnittstelle ist derzeit noch nicht implementiert.

## Server

Der Server ist zunächst für den Betrieb auf einem Raspberry Pi 5 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:

```text
go.bug.st/serial v1.7.1
```

Die 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:

```text
git.lang-dieter.de/third-party/go-serial
```

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 werden zunächst über ein vertrauenswürdiges Tailscale-Netz verbunden.

Eine zusätzliche TLS-Verschlüsselung ist deshalb derzeit nicht vorgesehen.

Für eine spätere Übertragung von Audio-Daten ist ein separates Netzwerk-/Transportkonzept vorgesehen. Hierfür soll UDP verwendet bzw. untersucht werden.

## Konfiguration

Client und Server erhalten jeweils eine eigene JSON-Konfiguration.

Über die Konfiguration sollen unter anderem festgelegt werden können:

- Netzwerkparameter
- serielle Schnittstelle
- Baudrate
- Datenbits
- Parität
- Stopbits
- Bezeichnung des Gerätes
- weitere für die jeweilige Schnittstelle erforderliche Parameter

Die konkrete Konfigurationsstruktur wird im weiteren Projektverlauf festgelegt.

## Diagnose und Logging

Für Debugging und Diagnose soll eine Protokollierung des übertragenen Datenverkehrs möglich sein.

Insbesondere soll eine Darstellung der übertragenen Bytes möglich sein, um Probleme bei der Kommunikation zwischen Hersteller-Software und Gerät analysieren zu können.

Während der Entwicklung kann `socat` als zusätzliches Werkzeug für Tests und Diagnose eingesetzt werden.

## Tests

Die wichtigsten Komponenten verfügen über automatisierte Tests.

Der aktuelle Stand wird unter anderem mit folgenden Befehlen geprüft:

```bash
go test ./...
```

und:

```bash
go test -race ./...
```

Der Race Detector wird eingesetzt, um Probleme bei der nebenläufigen Verarbeitung von Sessions, Data-Listenern und DataConnections zu erkennen.

Für die serielle Datenübertragung werden virtuelle serielle Schnittstellen über `socat` verwendet. Dadurch kann der Datenpfad ohne angeschlossene RS232-Hardware getestet werden.

Dabei werden insbesondere beide Übertragungsrichtungen geprüft:

```text
TCP → RS232
RS232 → TCP
```

## Projektstruktur

```text
rs2322tcp/
├── cmd/
│   ├── rs2322tcp-client/
│   └── rs2322tcp-server/
├── configs/
├── docs/
├── internal/
│   ├── client/
│   ├── config/
│   ├── serial/
│   ├── server/
│   ├── transport/
│   └── version/
├── scripts/
│   └── build.sh
├── CHANGELOG.md
├── LICENSE
├── README.md
└── go.mod
```

## Build

Der Build erfolgt über das zentrale Build-Skript:

```bash
./scripts/build.sh
```

Das 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:

- Linux amd64 – Client und Server
- Linux arm64 – Server
- Windows amd64 – Client

## Versionierung

Die Versionierung erfolgt über Git.

Die Git-Informationen werden beim Build in die Binärdateien eingebettet. Neben der Version werden unter anderem Build-Nummer, Commit und Build-Datum erfasst.

Release-Versionen werden über Git-Tags gekennzeichnet.

## Entwicklungsstand

Das Projekt befindet sich weiterhin in der frühen Entwicklungsphase.

Die ursprüngliche Projektgrundlage aus Version `0.0.1` wurde inzwischen um eine funktionierende serverseitige TCP-/RS232-Datenübertragung erweitert.

Implementiert und getestet sind derzeit:

- Server-Control-Verbindung
- Session-Verwaltung
- dynamische Data-Ports
- DataConnection
- bidirektionale TCP-/RS232-Datenübertragung
- Serial-Abstraktion
- Konfiguration der seriellen Parameter
- virtuelle serielle Integrationstests
- nebenläufigkeitssichere Data-Listener
- Race-Detection

Noch nicht implementiert ist insbesondere die clientseitige virtuelle serielle Schnittstelle für Windows und Linux.

## Lizenz

GPL-3.0-or-later