Neu

Delphi Serial Port Komponente für Windows, Linux und macOS

Eine nicht visuelle Komponente für COM-Ports, USB-Seriell-Adapter und RS-485-Busse. Empfange per Ereignis oder per blockierendem Lesen, schreibe aus jedem Thread und führe denselben Code unter Windows, Linux und macOS aus.

Enthalten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial.

Eine Serial-Port-Komponente, die überall gleich funktioniert

Barcodescanner, Waagen, GPS-Empfänger, Modems, Laborinstrumente und RS-485-Feldbusse, aus einer einzigen Pascal-Klasse.

Eine Delphi Serial Port Komponente muss mit drei Betriebssystemen umgehen, die serielle Ein-/Ausgabe auf unterschiedliche Weise erledigen: Overlapped I/O und DCB-Einstellungen unter Windows, termios und Dateideskriptoren unter Linux und macOS. TsgcSerialPort verbirgt all das hinter einem Satz von Eigenschaften (Port, BaudRate, DataBits, Parity, StopBits, FlowControl, RtsControl) und einem Satz von Aufrufen, sodass eine VCL-, FMX-, Dienst- oder Konsolenanwendung mit demselben Code COM3 unter Windows und /dev/ttyUSB0 unter Linux öffnet.

Die Daten treffen in einem Reader-Thread im Hintergrund ein. Weise OnData zu, um jeden Datenblock als Ereignis zu erhalten, oder lasse es leer, dann landen die Bytes in einem 64-KB-Empfangspuffer, den du mit Read lesen, mit einem Timeout für das erste Byte und einem Zeichenabstand-Timeout, das die Nachricht beendet. Schreibzugriffe werden von der Komponente serialisiert, daher kann jeder Thread senden.

Komponentenklasse

TsgcSerialPort, in der Unit sgcIndustrial

Portnamen

COM3, \\.\COM12, /dev/ttyUSB0 oder einfach ttyUSB0

Leitungseinstellungen

5 bis 8 Datenbits; Parität keine, ungerade, gerade, Mark oder Space; 1, 1,5 oder 2 Stoppbits; Flusssteuerung RTS/CTS, DTR/DSR oder XON/XOFF

Plattformen

Delphi 7 bis Delphi 13 und C++Builder; Windows 32 und 64 Bit, Linux 64 Bit und macOS

Einen Port öffnen, einen Befehl senden, die Antwort lesen

Drei Möglichkeiten, die Komponente zu verwenden. Jedes Beispiel lässt sich mit Delphi 7 und Delphi 13 kompilieren.

uses
  SysUtils, sgcIndustrial; // Delphi 7 to 2006: add sgcBase_Helpers (TBytes)

procedure TForm1.FormCreate(Sender: TObject);
begin
  Serial := TsgcSerialPort.Create(Self);
  Serial.Port := 'COM3';         // '/dev/ttyUSB0' on Linux, '/dev/cu.usbserial-10' on macOS
  Serial.BaudRate := 115200;
  Serial.DataBits := 8;
  Serial.Parity := spNone;
  Serial.StopBits := ssOne;
  Serial.FlowControl := sfcNone;
  Serial.OnData := SerialData;   // a reader thread receives, the event is queued
  Serial.OnError := SerialError; // to the main thread (NotifyEvents)
  Serial.Active := True;
  Serial.WriteString('AT' + #13);
end;

procedure TForm1.SerialData(Sender: TObject; const aData: TBytes);
begin
  Memo1.Lines.Add(Format('%d bytes received', [Length(aData)]));
end;

procedure TForm1.SerialError(Sender: TObject; const aError: string);
begin
  Memo1.Lines.Add('error: ' + aError);
end;
procedure TForm1.btnQueryClick(Sender: TObject);
var
  vData: TBytes;
  vCount: Integer;
begin
  Serial.OnData := nil;    // without OnData, bytes go to the 64 KB receive buffer
  Serial.Port := 'COM5';
  Serial.BaudRate := 9600;
  Serial.Active := True;
  Serial.Purge;
  Serial.WriteString('MEAS?' + #13#10);
  // wait up to 1 s for the first byte, then return after 50 ms of silence
  // or when 256 bytes have arrived
  vCount := Serial.Read(vData, 256, 1000, 50);
  if vCount = 0 then
    Memo1.Lines.Add('timeout')
  else
    Memo1.Lines.Add(Format('%d bytes', [vCount]));
  Serial.Active := False;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  // COM1, COM3, ... on Windows; /dev/ttyUSB0, /dev/ttyACM0, ... on Linux
  TsgcSerialPort.ListPorts(ComboBox1.Items);

  Serial := TsgcSerialPort.Create(Self);
  Serial.Port := 'COM4';
  Serial.BaudRate := 38400;
  Serial.Parity := spEven;
  Serial.RtsControl := srcToggle; // RS-485 half duplex: RTS on while sending
  Serial.WriteTimeout := 500;
  Serial.Active := True;

  Serial.SetDTR(True);
  if smsCTS in Serial.ModemStatus then
    Memo1.Lines.Add('CTS is on');
end;

Die Details, die serielle Programme zuverlässig machen

Threads, Timeouts, Puffer und abgezogene Adapter, alles innerhalb der Komponente behandelt.

Ereignis oder blockierendes Lesen

Ist OnData zugewiesen, wird jeder vom Reader-Thread empfangene Datenblock als Ereignis geliefert. Ohne es wartet Read(Data, MaxCount, Timeout, InterCharTimeout) auf das erste Byte und kehrt zurück, wenn MaxCount Bytes eingetroffen sind oder die Leitung für die Zeichenabstandszeit still blieb: der natürliche Weg, eine einzelne gerahmte Antwort zu lesen.

Ereignisse in dem Thread deiner Wahl

NotifyEvents stellt OnData, OnOpen, OnClose und OnError standardmäßig in die Warteschlange des Hauptthreads, kann sie synchronisieren oder direkt im Reader-Thread auslösen, für die geringste Latenz.

Schreiben aus jedem Thread

Write und WriteString werden durch eine interne Sperre serialisiert. Write liefert die Anzahl der geschriebenen Bytes, WriteTimeout begrenzt die Wartezeit, und WriteString sendet die UTF-8-Bytes eines Strings und löst eine Exception aus, wenn nicht alle geschrieben werden konnten.

Von überall schließen

Close ist aus jedem Thread sicher, sogar aus einem OnData-Handler heraus. Es weckt ein blockiertes Read, bricht einen blockierten Schreibvorgang ab und stoppt den Reader-Thread, unter Windows mit dem Abbruch von Overlapped I/O und unter Linux und macOS mit einem Abbruch-Flag und poll.

RS-485-Richtungssteuerung

RtsControl := srcToggle setzt RTS, solange der Port sendet, und nimmt es danach zurück, sodass ein RS-485-Transceiver den Bus für die Antwort freigibt. Windows nutzt den RTS-Toggle-Modus des Treibers, Linux den RS-485-Modus des Kernels für den seriellen Treiber.

Modemleitungen

SetDTR und SetRTS steuern die Ausgangsleitungen; ModemStatus liefert die Menge der aktiven Eingänge: smsCTS, smsDSR, smsRI und smsDCD.

Port-Erkennung

TsgcSerialPort.ListPorts fügt die Portnamen in natürlicher Reihenfolge (COM2 vor COM10) zu jedem TStrings hinzu: aus der Registry unter Windows, /dev/ttyS*, /dev/ttyUSB* und /dev/ttyACM* unter Linux und /dev/cu.* unter macOS.

Puffer unter Kontrolle

BufferCount gibt an, wie viele Bytes im 64-KB-Empfangspuffer warten, und Purge leert ihn zusammen mit den Puffern des Betriebssystems. Läuft der Puffer über, werden die ältesten Bytes verworfen und OnError wird einmal ausgelöst.

Fehler mit dem OS-Code

Jeder Fehler löst EsgcSerialError aus, dessen ErrorCode den Windows-Fehler oder den POSIX-errno enthält. Wird ein USB-Adapter abgezogen, wird OnError einmal ausgelöst und der Port wartet auf Close. Unter Linux und macOS wird der Port im exklusiven Modus geöffnet.

Was jedes Betriebssystem unterstützt

Eine Einstellung, die die Plattform nicht umsetzen kann, löst bei Open EsgcSerialError aus, statt ignoriert zu werden.

FunktionWindowsLinuxmacOS
BaudratenJede Rate, die der Treiber akzeptiertStandardraten, 50 bis 4.000.000Standardraten, 50 bis 230.400
Parität Mark und SpaceJaJaNein
Flusssteuerung RTS/CTS und XON/XOFFJaJaJa
Flusssteuerung DTR/DSRJaNeinNein
RS-485 RTS toggleJa, Toggle-Modus des TreibersJa, RS-485-Modus des Kernels (Treiberunterstützung erforderlich)Nein
PortlisteRegistry/dev/ttyS*, ttyUSB*, ttyACM*/dev/cu.*

Die Komponente wurde an einem echten COM-Port unter Windows (32 und 64 Bit) und an Pseudo-Terminals unter Linux 64 Bit getestet; derselbe Code lässt sich für macOS kompilieren. Android und iOS werden nicht unterstützt.

Der Transport für Modbus RTU

TsgcSerialPort ist auch die serielle Leitung unter den Delphi Modbus RTU Komponenten. Weise der Eigenschaft SerialPort von TsgcModbusRTUClient einen geöffneten Port zu, um Slaves an einem RS-485-Bus abzufragen, oder der von TsgcModbusRTUServer, um als Slave zu antworten. Die Modbus-Komponenten kümmern sich um die Frame-Pause von 3,5 Zeichen, die CRC und die Slave-Adresse; der Port benötigt nur die Leitungseinstellungen des Busses, typischerweise 19200 Baud, 8 Datenbits, gerade Parität und 1 Stoppbit.

Fragen zum Delphi Serial Port

Erstelle ein TsgcSerialPort, setze Port (zum Beispiel COM3), BaudRate, DataBits, Parity und StopBits und setze Active := True oder rufe Open auf. Ports oberhalb von COM9 funktionieren auch mit dem einfachen Namen; die Komponente ergänzt das von Windows benötigte Präfix \\.\.

Lasse OnData unzugewiesen und rufe Read(Data, MaxCount, Timeout, InterCharTimeout) auf. Es wartet bis zu Timeout Millisekunden auf das erste Byte und kehrt zurück, wenn MaxCount Bytes eingetroffen sind oder InterCharTimeout Millisekunden lang kein Byte kam. Das Ergebnis ist die Anzahl der gelesenen Bytes, 0 bedeutet Timeout. Nur ein Thread sollte Read gleichzeitig aufrufen.

Ja, mit jedem Adapter, den das Betriebssystem als seriellen Port bereitstellt: ein COM-Port unter Windows, /dev/ttyUSB* oder /dev/ttyACM* unter Linux, /dev/cu.* unter macOS. Wird der Adapter bei geöffnetem Port abgezogen, wird OnError einmal ausgelöst; rufe Close auf und öffne den Port erneut, sobald der Adapter wieder da ist.

Konverter mit automatischer Richtungssteuerung benötigen keine Einstellung. Setze bei Konvertern, die über RTS gesteuert werden, RtsControl := srcToggle: RTS wird gesetzt, solange der Port sendet, und zurückgenommen, wenn das letzte Byte hinausgegangen ist. Windows erledigt das im seriellen Treiber und Linux im RS-485-Modus des Kernels, den der serielle Treiber unterstützen muss; andernfalls löst Open eine klare EsgcSerialError aus.

Schreibzugriffe können aus jedem Thread kommen und werden von der Komponente serialisiert. Close kann aus jedem Thread aufgerufen werden, auch aus dem Reader-Thread in einem Ereignis-Handler. Lesezugriffe sind für jeweils einen Aufrufer gedacht, so wie ein Request-Response-Protokoll eine serielle Leitung ohnehin nutzt.

Delphi 7 bis Delphi 13 und C++Builder, unter Windows 32 und 64 Bit, Linux 64 Bit und macOS. Android und iOS werden nicht unterstützt.

TsgcSerialPort ist zusammen mit den Modbus-Komponenten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial enthalten.

Weitere industrielle Komponenten in sgcWebSockets

Serial-Port-Referenz

Jede Eigenschaft, Methode und jedes Ereignis von TsgcSerialPort.

Industrielle Komponenten

Serial Port, Modbus und OPC UA in einem Bereich von sgcWebSockets.

Delphi Modbus TCP und RTU

Modbus-Clients und -Server, die diese Komponente für die serielle Leitung verwenden.

C# Modbus für .NET

Die .NET-Edition hat ebenfalls ein TsgcSerialPort, neben den Modbus-Komponenten.

Bestes Preis-Leistungs-Verhältnis: All-AccessAlle eSeGeCe-Produkte, inklusive Premium-Support, ab €1,059 pro Jahr.
All-Access-Preise ansehen

Verbinde dein erstes serielles Gerät mit Delphi

Enthalten in sgcWebSockets Enterprise (Delphi und .NET) und All-Access oder im eigenständigen Paket sgcIndustrial.