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
QuickStart
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 = 0then
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;
Fonctionnalités
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.
Plateformes
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é
Windows
Linux
macOS
Débits en bauds
Tout débit accepté par le pilote
Débits standard, de 50 à 4 000 000
Débits standard, de 50 à 230 400
Parité mark et space
Oui
Oui
Non
Contrôle de flux RTS/CTS et XON/XOFF
Oui
Oui
Oui
Contrôle de flux DTR/DSR
Oui
Non
Non
Bascule RTS RS-485
Oui, mode de bascule du pilote
Oui, mode RS-485 du noyau (prise en charge par le pilote requise)
Non
Liste des ports
Registre
/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.
Modbus RTU
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.
FAQ
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.