Implémentation de la communication série dans Delphi

Implémentation de la communication série dans Delphi

Avec le développement des technologies de l'information modernes et l'utilisation généralisée des réseaux informatiques, la technologie de communication informatique est devenue de plus en plus mature. Cependant, la communication série, en tant que méthode de communication flexible, pratique et fiable, reste une méthode de communication efficace et est largement utilisée dans l'industrie. contrôle. Dans la pratique de la production industrielle, l'utilisation d'un PC pour surveiller des projets en temps réel nécessite généralement que le PC dispose de fonctions telles que la collecte de données, le traitement des données, ainsi que la génération et la transmission de signaux de contrôle sur l'interface utilisateur. Dans cet environnement spécifique, si le PC doit être connecté aux signaux en temps réel du contrôle de processus, il est nécessaire d'exploiter directement le port série du PC. Delphi lancé par Borland est un puissant langage de programmation de haut niveau doté de fonctionnalités visuelles orientées objet et particulièrement adapté à la préparation d'interfaces graphiques et de programmes utilisateur dans l'environnement Windows.

Mécanisme de communication série basé sur WIN95/NT

Le mécanisme du système d'exploitation Windows interdit aux applications d'accéder directement au matériel informatique, mais il fournit aux programmeurs une série de fonctions API standard, rendant la préparation des applications plus pratique et éliminant les problèmes de débogage du matériel associé. Sous Windows 95/NT, le message WM_COMMNOTIFY original de Windows 3. Il suffit d'opérer sur le tampon de lecture/écriture. Plusieurs fonctions d'opération de communication série couramment utilisées dans WIN95/NT sont les suivantes :

CreatFile ouvre le port série

CloseHandle ferme le port série

SetupComm définit la taille du tampon de communication

ReadFile lit le fonctionnement du port série

WriteFile écrit l'opération du port série

SetCommState définit les paramètres de communication

GetCommState obtient les paramètres de communication par défaut

ClearCommError efface l'erreur du port série et obtient l'état actuel

En plus des fonctions ci-dessus, un enregistrement important DCB (Device Control Block) est souvent utilisé. Il existe des paramètres de port série définissables enregistrés dans DCB. Lors de la définition des paramètres du port série, vous devez d'abord utiliser la fonction GetCommState pour remplir les valeurs par défaut du système dans le bloc de contrôle DCB, puis définir les valeurs personnalisées que l'utilisateur a définies. veut changer.

Pour effectuer une communication série sous WIN95/NT, en plus de comprendre les fonctions de base des opérations de communication, vous devez également maîtriser la programmation multi-thread. Un thread est le chemin d'exécution au sein d'un processus et constitue l'entité de base utilisée par le système d'exploitation pour allouer du temps CPU. Chaque processus commence par un seul thread pour terminer l'exécution de l'application. La communication série doit être implémentée à l'aide de la technologie multithread. Sa logique de traitement principale peut être exprimée comme suit : au début du processus, le thread principal effectue le travail d'initialisation nécessaire, puis le thread principal établit un thread de surveillance de la communication pour surveiller. le port de communication au moment approprié selon les besoins. Lorsque l'événement de port série spécifié se produit, un message WM_COMMNOTIFY est envoyé au thread principal (puisque WIN95 annule le message WM_COMMNOTIFY, vous devez le créer vous-même) et le thread principal le traite. Si le message WM_COMMNOTIFY n'est pas nécessaire, le thread principal met fin au thread de surveillance des communications.

L'exécution simultanée de plusieurs threads provoquera des conflits sur les ressources partagées. Pour éviter les conflits, il est nécessaire d'utiliser des multi-threads synchronisés pour accéder aux ressources partagées. WIN95 fournit de nombreuses méthodes pour maintenir la synchronisation des threads. L'auteur utilise la création d'objets d'événement pour maintenir la synchronisation des threads. Créez un objet événement via CraeteEvent() et définissez l'objet événement pour signaler la synchronisation à l'aide de la fonction etEvent() ou PulseEvent(). Dans l'application, utilisez la fonction WaitSingleObject() pour attendre le déclencheur de synchronisation et attendez que l'événement spécifié soit défini pour recevoir un signal par d'autres threads avant de continuer à exécuter le programme.

Méthode d'implémentation spécifique sous Delphi

Les fonctions puissantes de Delphi et la technologie de programmation orientée objet prenant en charge le multithreading rendent la communication série très simple et pratique. Il est implémenté en appelant des fonctions API externes. Les principales étapes sont les suivantes : Premièrement, utilisez la fonction CreateFile pour ouvrir le port série afin de déterminer la propriété du port série par cette application et empêcher d'autres applications d'exploiter le port série. , remplissez le bloc de contrôle de l'appareil DCB via la fonction GetCommState, puis configurez le débit en bauds, les bits de données, les bits de parité et les bits d'arrêt du port série en appelant la fonction SetCommState. Créez ensuite un thread de surveillance du port série pour surveiller les événements du port série. Sur cette base, vous pouvez opérer la transmission des données sur le port série correspondant ; enfin, utiliser la fonction CloseHandle pour fermer le port série. Le programme spécifique est le suivant. Ce programme a été compilé avec Delphi3.0 et débogué dans l'environnement Win95. Il a été mis en application pratique pour la référence des lecteurs.

programme:

unité comdemou;

interface

utilise

Windows, messages, SysUtils, classes, graphiques, contrôles, formulaires, boîtes de dialogue ;

const

Wm_commNotify=Wm_User+12;

taper

TForm1 = classe(TForm)

PRocédure FormCreate(Expéditeur : TObject);

privé

Procédure de cominitialisation ;

Procédure MsgcommProcess(Var Message:Tmessage); Message Wm_commnotify;

{Déclarations privées}

publique

{Déclarations publiques}

fin;

//Déclaration du fil de discussion

TComm=Classe(TThread)

protégé

procédure Exécuter ; remplacer ;

fin;

var

Formulaire1 : TForm1 ;

hcom,Post_Event:Thandle;

lpol : superposé ;

mise en œuvre

{$R *.DFM}

Procédure TComm.Execute; //Processus d'exécution du thread

var

dwEvtMask:DWord;

Attendez : booléen ;

Commencer

fillchar(lpol,sizeof(toverlapped),0);

Tant que la vérité commence

dwEvtMask:=0;

Wait:=WaitCommEvent(hcom,dwevtmask,lpol); //Attendez les événements du port série ;

si attendez, commencez

waitforsingleobject(post_event,infinite); //Attendez que l'événement de synchronisation soit défini ;

resetevent(post_event); //Réinitialisation de l'événement de synchronisation ;

PostMessage(Form1.Handle,WM_COMMNOTIFY,0,0);//Envoyer un message;

fin;

fin;

fin;

procédure Tform1.comminitialize; //Initialisation du port série

var

lpdcb:Tdcb;

Commencer

hcom:=createfile('com2',generic_read ou generic_write,0,nil,open_existing,

file_attribute_normal ou file_flag_overlapped,0);//Ouvrir le port série

si hcom=invalid_handle_value alors

autre

setupcomm(hcom,4096,4096); //Définit les tampons d'entrée et de sortie sur 4096 octets

getcommstate(hcom,lpdcb); //Obtenir les paramètres par défaut actuels du port série

lpdcb.baudrate:=2400;

lpdcb.StopBits:=1;

lpdcb.ByteSize:=8;

lpdcb.Parity:=EvenParity; //Parité paire

Setcommstate(hcom,lpdcb);

setcommMask(hcom,ev_rxchar);

//Spécifiez l'événement du port série sous forme de caractères reçus ;

fin;

Procédure TForm1.MsgcommProcess(Var Message:Tmessage);

var

Clair : booléen ;

Com:Tcomstat;

cbNum,ReadNumber,lpErrors:Integer ;

Read_Buffer:tableau[1..100]de caractères ;

Commencer

Clear:=Clearcommerror(hcom,lpErrors,@Coms);

si clair, alors commencez

cbNum:=Coms.cbInQue;

ReadFile(hCom,Read_Buffer,cbNum,ReadNumber,lpol);

// Traite les données reçues

SetEvent(Post_Event); //Paramètre de l'événement de synchronisation

fin;

fin;

procédure TForm1.FormCreate(Expéditeur : TObject);

commencer

Comminitialiser ;

post_event:=CreateEvent(nil,true,true,nil); //Créer un événement de synchronisation ;

Tcomm.Create(False); //Créer un thread de surveillance du port série ;

fin;

fin.

Nom du membre auteur : ruan_bangqiu