Nouveau

Composant de port série Delphi pour Windows, Linux et macOS

Un composant non visuel pour les ports COM, les adaptateurs série USB et les bus RS-485. Reçois les données avec un événement ou une lecture bloquante, écris depuis n'importe quel thread et exécute le même code sous Windows, Linux et macOS.

Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial.

Un composant de port série qui se comporte de la même façon partout

Lecteurs de codes-barres, balances, récepteurs GPS, modems, instruments de laboratoire et bus de terrain RS-485, depuis une seule classe Pascal.

Un composant de port série Delphi doit gérer trois systèmes d'exploitation qui font de l'E/S série de façons différentes : E/S overlapped et paramètres DCB sous Windows, termios et descripteurs de fichiers sous Linux et macOS. TsgcSerialPort masque tout cela derrière un seul jeu de propriétés (Port, BaudRate, DataBits, Parity, StopBits, FlowControl, RtsControl) et un seul jeu d'appels, si bien qu'une application VCL, FMX, service ou console ouvre COM3 sous Windows et /dev/ttyUSB0 sous Linux avec le même code.

Les données arrivent dans un thread de lecture en arrière-plan. Assigne OnData pour recevoir chaque bloc sous forme d'événement, ou laisse-le vide et les octets vont dans un tampon de réception de 64 Ko que tu lis avec Read, avec un délai pour le premier octet et un délai inter-caractères qui termine le message. Les écritures sont sérialisées par le composant, donc n'importe quel thread peut envoyer.

Classe de composant

TsgcSerialPort, dans l'unité sgcIndustrial

Noms de ports

COM3, \\.\COM12, /dev/ttyUSB0 ou simplement ttyUSB0

Paramètres de ligne

5 à 8 bits de données ; parité nulle, impaire, paire, mark ou space ; 1, 1,5 ou 2 bits d'arrêt ; contrôle de flux RTS/CTS, DTR/DSR ou XON/XOFF

Plateformes

Delphi 7 à Delphi 13 et C++Builder ; Windows 32 et 64 bits, Linux 64 bits et macOS

Ouvre un port, envoie une commande, lis la réponse

Trois façons d'utiliser le composant. Chaque exemple compile avec Delphi 7 et 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;

Les détails qui rendent le code série fiable

Threads, délais, tampons et adaptateurs débranchés, gérés à l'intérieur du composant.

Événement ou lecture bloquante

Avec OnData assigné, chaque bloc reçu par le thread de lecture est livré sous forme d'événement. Sans lui, Read(Data, MaxCount, Timeout, InterCharTimeout) attend le premier octet, puis revient quand MaxCount octets sont arrivés ou que la ligne est restée silencieuse pendant le délai inter-caractères : la façon naturelle de lire une réponse encadrée.

Des événements sur le thread de ton choix

NotifyEvents met en file OnData, OnOpen, OnClose et OnError vers le thread principal par défaut, peut les synchroniser, ou peut les déclencher directement dans le thread de lecture pour la latence la plus faible.

Écrire depuis n'importe quel thread

Write et WriteString sont sérialisés par un verrou interne. Write renvoie le nombre d'octets écrits, WriteTimeout limite la durée d'attente, et WriteString envoie les octets UTF-8 d'une chaîne et lève une exception si tous n'ont pas pu être écrits.

Fermer depuis n'importe où

Close peut être appelé depuis n'importe quel thread, même depuis un gestionnaire OnData. Il réveille un Read bloqué, annule une écriture bloquée et arrête le thread de lecture, grâce à l'annulation d'E/S overlapped sous Windows et à un indicateur d'annulation avec poll sous Linux et macOS.

Contrôle de direction RS-485

RtsControl := srcToggle lève RTS pendant que le port émet et le relâche ensuite, de sorte qu'un transceiver RS-485 libère le bus pour la réponse. Windows utilise le mode de bascule RTS du pilote, Linux le mode RS-485 du noyau pour le pilote série.

Lignes modem

SetDTR et SetRTS pilotent les lignes de sortie ; ModemStatus renvoie l'ensemble des entrées actives : smsCTS, smsDSR, smsRI et smsDCD.

Découverte des ports

TsgcSerialPort.ListPorts ajoute les noms de ports à n'importe quel TStrings dans l'ordre naturel (COM2 avant COM10) : depuis le registre sous Windows, /dev/ttyS*, /dev/ttyUSB* et /dev/ttyACM* sous Linux, et /dev/cu.* sous macOS.

Des tampons maîtrisés

BufferCount indique combien d'octets attendent dans le tampon de réception de 64 Ko et Purge le vide ainsi que les tampons du système d'exploitation. Si le tampon déborde, les octets les plus anciens sont abandonnés et OnError se déclenche une seule fois.

Des erreurs avec le code du système

Chaque échec lève EsgcSerialError, dont ErrorCode contient l'erreur Windows ou le errno POSIX. Quand un adaptateur USB est débranché, OnError se déclenche une fois et le port attend Close. Sous Linux et macOS, le port est ouvert en mode exclusif.

Ce que chaque système d'exploitation prend en charge

Un réglage que la plateforme ne sait pas faire lève EsgcSerialError à Open au lieu d'être ignoré.

FonctionnalitéWindowsLinuxmacOS
Débits en baudsTout débit accepté par le piloteDébits standard, de 50 à 4 000 000Débits standard, de 50 à 230 400
Parité mark et spaceOuiOuiNon
Contrôle de flux RTS/CTS et XON/XOFFOuiOuiOui
Contrôle de flux DTR/DSROuiNonNon
Bascule RTS RS-485Oui, mode de bascule du piloteOui, mode RS-485 du noyau (prise en charge par le pilote requise)Non
Liste des portsRegistre/dev/ttyS*, ttyUSB*, ttyACM*/dev/cu.*

Le composant est testé sur un vrai port COM sous Windows (32 et 64 bits) et sur des pseudo-terminaux sous Linux 64 bits ; le même code compile pour macOS. Android et iOS ne sont pas pris en charge.

Le transport pour Modbus RTU

TsgcSerialPort est aussi la ligne série sous les composants Modbus RTU pour Delphi. Assigne un port ouvert à la propriété SerialPort de TsgcModbusRTUClient pour interroger des esclaves sur un bus RS-485, ou de TsgcModbusRTUServer pour répondre en tant qu'esclave. Les composants Modbus s'occupent de l'intervalle de trame de 3,5 caractères, du CRC et de l'adresse de l'esclave ; le port n'a besoin que des réglages de ligne du bus, typiquement 19200 bauds, 8 bits de données, parité paire et 1 bit d'arrêt.

Questions sur le port série Delphi

Crée un TsgcSerialPort, renseigne Port (par exemple COM3), BaudRate, DataBits, Parity et StopBits, puis mets Active := True ou appelle Open. Les ports au-delà de COM9 fonctionnent aussi avec le nom simple ; le composant ajoute le préfixe \\.\ dont Windows a besoin.

Laisse OnData non assigné et appelle Read(Data, MaxCount, Timeout, InterCharTimeout). Il attend jusqu'à Timeout millisecondes le premier octet, puis revient quand MaxCount octets sont arrivés ou qu'aucun octet n'est venu pendant InterCharTimeout millisecondes. Le résultat est le nombre d'octets lus, et 0 signifie un délai dépassé. Un seul thread à la fois doit appeler Read.

Oui, avec tout adaptateur que le système d'exploitation expose comme port série : un port COM sous Windows, /dev/ttyUSB* ou /dev/ttyACM* sous Linux, /dev/cu.* sous macOS. Si l'adaptateur est débranché alors que le port est ouvert, OnError se déclenche une fois ; appelle Close et rouvre le port quand l'adaptateur est de retour.

Les convertisseurs à contrôle de direction automatique n'ont besoin d'aucun réglage. Pour les convertisseurs pilotés par RTS, mets RtsControl := srcToggle : RTS est levé pendant que le port émet et relâché quand le dernier octet est parti. Windows le fait dans le pilote série et Linux dans le mode RS-485 du noyau, que le pilote série doit prendre en charge ; sinon Open lève un EsgcSerialError explicite.

Les écritures peuvent venir de n'importe quel thread et sont sérialisées par le composant. Close peut être appelé depuis n'importe quel thread, y compris le thread de lecture dans un gestionnaire d'événement. Les lectures sont prévues pour un seul appelant à la fois, ce qui correspond de toute façon à l'usage d'un protocole requête-réponse sur une ligne série.

Delphi 7 à Delphi 13 et C++Builder, sous Windows 32 et 64 bits, Linux 64 bits et macOS. Android et iOS ne sont pas pris en charge.

TsgcSerialPort est inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial, avec les composants Modbus.

Plus de composants industriels dans sgcWebSockets

Référence du port série

Chaque propriété, méthode et événement de TsgcSerialPort.

Composants industriels

Port série, Modbus et OPC UA dans une seule section de sgcWebSockets.

Modbus TCP et RTU pour Delphi

Des clients et serveurs Modbus qui utilisent ce composant pour la ligne série.

Modbus C# pour .NET

L'édition .NET a aussi un TsgcSerialPort, à côté des composants Modbus.

Meilleur rapport qualité-prix : All-AccessTous les produits eSeGeCe, Support Premium inclus, à partir de €1,059/an.
Voir les tarifs All-Access

Connecte ton premier appareil série depuis Delphi

Inclus dans sgcWebSockets Enterprise (Delphi et .NET) et All-Access, ou dans le pack autonome sgcIndustrial.