Nieuw

Delphi seriële poort-component voor Windows, Linux en macOS

Eén niet-visuele component voor COM-poorten, USB-seriële adapters en RS-485-bussen. Ontvang met een event of met een blokkerende read, schrijf vanuit elke thread en draai dezelfde code op Windows, Linux en macOS.

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.

Een seriële poort-component die overal hetzelfde werkt

Barcodescanners, weegschalen, GPS-ontvangers, modems, labinstrumenten en RS-485-veldbussen, vanuit één Pascal-klasse.

Een Delphi seriële poort-component moet omgaan met drie besturingssystemen die seriële I/O op verschillende manieren afhandelen: overlapped I/O en DCB-instellingen op Windows, termios en file descriptors op Linux en macOS. TsgcSerialPort verbergt dat alles achter één set eigenschappen (Port, BaudRate, DataBits, Parity, StopBits, FlowControl, RtsControl) en één set aanroepen, zodat een VCL-, FMX-, service- of consoletoepassing met dezelfde code COM3 opent op Windows en /dev/ttyUSB0 op Linux.

Data komt binnen in een leesthread op de achtergrond. Wijs OnData toe om elk blok als event te ontvangen, of laat het leeg en de bytes gaan naar een ontvangstbuffer van 64 KB die je leest met Read, met een timeout voor de eerste byte en een timeout tussen tekens die het bericht afsluit. Schrijfacties worden door de component geserialiseerd, zodat elke thread kan verzenden.

Componentklasse

TsgcSerialPort, in de unit sgcIndustrial

Poortnamen

COM3, \\.\COM12, /dev/ttyUSB0 of gewoon ttyUSB0

Lijninstellingen

5 tot 8 databits; pariteit geen, oneven, even, mark of space; 1, 1,5 of 2 stopbits; RTS/CTS-, DTR/DSR- of XON/XOFF-flowcontrol

Platformen

Delphi 7 tot Delphi 13 en C++Builder; Windows 32 en 64 bit, Linux 64 bit en macOS

Open een poort, verstuur een commando, lees het antwoord

Drie manieren om de component te gebruiken. Elk voorbeeld compileert met Delphi 7 en Delphi 13.

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;

De details die seriële code betrouwbaar maken

Threads, timeouts, buffers en losgekoppelde adapters, afgehandeld in de component.

Event of blokkerende read

Met OnData toegewezen wordt elk blok dat de leesthread ontvangt als event afgeleverd. Zonder dit wacht Read(Data, MaxCount, Timeout, InterCharTimeout) op de eerste byte en keert terug zodra MaxCount bytes zijn binnengekomen of de lijn de tijd tussen tekens stil bleef: de natuurlijke manier om één afgebakend antwoord te lezen.

Events op de thread van jouw keuze

NotifyEvents zet OnData, OnOpen, OnClose en OnError standaard in de wachtrij van de hoofdthread, kan ze synchroniseren of ze direct in de leesthread laten optreden voor de laagste latentie.

Schrijven vanuit elke thread

Write en WriteString worden geserialiseerd door een interne lock. Write geeft het aantal geschreven bytes terug, WriteTimeout begrenst hoe lang er gewacht wordt en WriteString verstuurt de UTF-8-bytes van een string en geeft een exception als ze niet allemaal geschreven konden worden.

Overal sluiten

Close is veilig vanuit elke thread, zelfs vanuit een OnData-handler. Het maakt een geblokkeerde Read wakker, annuleert een geblokkeerde schrijfactie en stopt de leesthread, met annulering van overlapped I/O op Windows en een annuleringsvlag met poll op Linux en macOS.

RS-485-richtingsbesturing

RtsControl := srcToggle zet RTS hoog terwijl de poort verzendt en laat het daarna zakken, zodat een RS-485-transceiver de bus vrijgeeft voor het antwoord. Windows gebruikt de RTS-toggle-modus van de driver, Linux de kernel-RS-485-modus van de seriële driver.

Modemlijnen

SetDTR en SetRTS sturen de uitgangslijnen aan; ModemStatus geeft de set actieve ingangen terug: smsCTS, smsDSR, smsRI en smsDCD.

Poortdetectie

TsgcSerialPort.ListPorts voegt de poortnamen in natuurlijke volgorde toe aan elke TStrings (COM2 voor COM10): uit het register op Windows, /dev/ttyS*, /dev/ttyUSB* en /dev/ttyACM* op Linux, en /dev/cu.* op macOS.

Buffers onder controle

BufferCount geeft aan hoeveel bytes in de ontvangstbuffer van 64 KB wachten en Purge maakt die leeg, samen met de buffers van het besturingssysteem. Als de buffer overloopt, worden de oudste bytes weggegooid en treedt OnError één keer op.

Fouten met de OS-code

Elke fout geeft EsgcSerialError, waarvan ErrorCode de Windows-fout of de POSIX-errno bevat. Als een USB-adapter wordt losgekoppeld, treedt OnError één keer op en wacht de poort op Close. Op Linux en macOS wordt de poort in exclusieve modus geopend.

Wat elk besturingssysteem ondersteunt

Een instelling die het platform niet kan uitvoeren geeft bij Open een EsgcSerialError in plaats van te worden genegeerd.

FunctieWindowsLinuxmacOS
BaudratesElke snelheid die de driver accepteertStandaardsnelheden, 50 tot 4.000.000Standaardsnelheden, 50 tot 230.400
Mark- en space-pariteitJaJaNee
RTS/CTS- en XON/XOFF-flowcontrolJaJaJa
DTR/DSR-flowcontrolJaNeeNee
RS-485 RTS-toggleJa, toggle-modus van de driverJa, kernel-RS-485-modus (driverondersteuning nodig)Nee
PoortlijstRegister/dev/ttyS*, ttyUSB*, ttyACM*/dev/cu.*

De component is getest op een echte COM-poort op Windows (32 en 64 bit) en op pseudo-terminals op Linux 64 bit; dezelfde code compileert voor macOS. Android en iOS worden niet ondersteund.

Het transport voor Modbus RTU

TsgcSerialPort is ook de seriële lijn onder de Delphi Modbus RTU-componenten. Wijs een geopende poort toe aan de eigenschap SerialPort van TsgcModbusRTUClient om slaves op een RS-485-bus te pollen, of van TsgcModbusRTUServer om als slave te antwoorden. De Modbus-componenten verzorgen de framepauze van 3,5 tekens, de CRC en het slave-adres; de poort heeft alleen de lijninstellingen van de bus nodig, meestal 19200 baud, 8 databits, even pariteit en 1 stopbit.

Vragen over de Delphi seriële poort

Maak een TsgcSerialPort, stel Port in (bijvoorbeeld COM3), BaudRate, DataBits, Parity en StopBits, en zet Active := True of roep Open aan. Poorten boven COM9 werken ook met de gewone naam; de component voegt het voorvoegsel \\.\ toe dat Windows nodig heeft.

Laat OnData ongebruikt en roep Read(Data, MaxCount, Timeout, InterCharTimeout) aan. Het wacht maximaal Timeout milliseconden op de eerste byte en keert terug zodra MaxCount bytes zijn binnengekomen of er InterCharTimeout milliseconden geen byte kwam. Het resultaat is het aantal gelezen bytes, en 0 betekent een timeout. Slechts één thread tegelijk mag Read aanroepen.

Ja, met elke adapter die het besturingssysteem als seriële poort aanbiedt: een COM-poort op Windows, /dev/ttyUSB* of /dev/ttyACM* op Linux, /dev/cu.* op macOS. Als de adapter wordt losgekoppeld terwijl de poort open is, treedt OnError één keer op; roep Close aan en open de poort opnieuw als de adapter terug is.

Converters met automatische richtingsbesturing hebben geen instelling nodig. Stel voor converters die door RTS worden aangestuurd RtsControl := srcToggle in: RTS gaat hoog terwijl de poort verzendt en zakt als de laatste byte is vertrokken. Windows doet dit in de seriële driver en Linux in de kernel-RS-485-modus, die de seriële driver moet ondersteunen; anders geeft Open een duidelijke EsgcSerialError.

Schrijfacties kunnen vanuit elke thread komen en worden door de component geserialiseerd. Close kan vanuit elke thread worden aangeroepen, ook vanuit de leesthread binnen een event-handler. Reads zijn bedoeld voor één aanroeper tegelijk, en zo gebruikt een request-response-protocol een seriële lijn toch al.

Delphi 7 tot Delphi 13 en C++Builder, op Windows 32 en 64 bit, Linux 64 bit en macOS. Android en iOS worden niet ondersteund.

TsgcSerialPort is inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial, samen met de Modbus-componenten.

Meer industriële componenten in sgcWebSockets

Referentie seriële poort

Elke eigenschap, methode en elk event van TsgcSerialPort.

Industriële componenten

Seriële poort, Modbus en OPC UA in één sectie van sgcWebSockets.

Delphi Modbus TCP en RTU

Modbus-clients en -servers die deze component voor de seriële lijn gebruiken.

C# Modbus voor .NET

De .NET-editie heeft ook een TsgcSerialPort, naast de Modbus-componenten.

De beste deal: All-AccessElk eSeGeCe-product, inclusief Premium-ondersteuning, vanaf €1,059 per jaar.
Bekijk de All-Access-prijzen

Verbind je eerste seriële apparaat vanuit Delphi

Inbegrepen in sgcWebSockets Enterprise (Delphi en .NET) en All-Access, of in het standalone pakket sgcIndustrial.