Delphi est un outil de développement d'applications visuel rapide offrant les avantages de fonctions puissantes, d'une facilité d'utilisation et d'une exécution rapide du code. Il joue un rôle de plus en plus important dans la création de systèmes d'information d'entreprise. De nombreux programmeurs sont prêts à choisir Delphi comme outil de développement. . Cependant, le problème est que Delphi ne dispose pas de son propre contrôle de communication série et qu'il n'y a aucune mention de communication série dans sa documentation d'aide, ce qui apporte beaucoup d'inconvénients aux développeurs qui compilent des programmes de communication.
Actuellement, il existe trois méthodes couramment utilisées pour implémenter la communication série à l'aide de Delphi : l'une consiste à utiliser des contrôles, tels que le contrôle MSCOMM et le contrôle SPCOMM ; l'autre consiste à utiliser des fonctions API ; la troisième consiste à appeler d'autres programmes de communication série. Parmi eux, l'utilisation d'API pour écrire des programmes de communication série est plus compliquée et nécessite beaucoup de connaissances en communication. En comparaison, il est relativement simple d'utiliser le contrôle SPCOMM, et le contrôle possède de riches propriétés et événements étroitement liés à la communication du port série, fournit diverses opérations sur le port série et prend également en charge le multithread. L'article suivant présente l'utilisation du contrôle SPCOMM en détail avec des exemples.
Installation SPCOMM
1. Sélectionnez l'option Installer le composant dans le menu déroulant Composant, renseignez le chemin où se trouve le contrôle SPCOMM dans le nom du fichier de l'unité, les valeurs par défaut peuvent être utilisées pour d'autres éléments, puis cliquez sur le bouton OK.
2. Après l'installation, un COM de contrôle rouge apparaîtra dans le panneau de configuration du système. Vous pouvez désormais utiliser les contrôles COM comme les propres contrôles de Delphi.
Propriétés, méthodes et événements SPCOMM
1.Attributs
●CommName : indique les noms des ports série tels que COM1 et COM2 ;
●BaudRate : Le débit en bauds défini en fonction des besoins réels. Cette valeur peut également être modifiée après l'ouverture du port série, et le débit en bauds réel changera en conséquence ;
●ParityCheck : indique si un contrôle de parité est requis ;
●ByteSize : La longueur d'octet définie en fonction de la situation réelle ;
●Parité : bit de parité ;
●StopBits : bits d'arrêt ;
●SendDataEmpty : Il s'agit d'un attribut booléen Lorsqu'il est vrai, cela signifie que le tampon d'envoi est vide, ou qu'il n'y a aucune information dans la file d'attente d'envoi, lorsqu'il est faux, cela signifie que le tampon d'envoi n'est pas vide, ou qu'il n'y a aucune information dans la file d'attente d'envoi. est une information dans la file d'attente d'envoi.
2. méthode
●La méthode Startcomm est utilisée pour ouvrir le port série. Lorsque l'ouverture échoue, une erreur est généralement signalée. Il existe sept principaux types d'erreurs : ⑴ Le port série a été ouvert ; ⑵ Erreur lors de l'ouverture du port série ; ⑶ Le descripteur de fichier n'est pas un descripteur de communication ; ⑷ Le cache de communication ne peut pas être installé ; ⑸ L'événement ne peut pas être généré ; Le processus de lecture ne peut pas être généré ; ⑺ Le processus d'écriture ne peut pas être généré ;
●La méthode StopComm est utilisée pour fermer le port série et n'a aucune valeur de retour ;
●La méthode WriteCommData(pDataToWrite: PChar;dwSizeofDataToWrite:Word) est une fonction avec une valeur de retour booléenne. Elle est utilisée pour envoyer une chaîne au processus d'écriture. Elle renvoie true si l'envoi réussit et false si l'envoi échoue. L'exécution de cette fonction obtiendra immédiatement la valeur de retour et l'opération d'envoi sera exécutée ultérieurement. Cette fonction a deux paramètres, où pDataToWrite est la chaîne à envoyer et dwSizeofDataToWrite est la longueur de la chaîne à envoyer.
3. événement
●OnReceiveData :PRocedure (Expéditeur : TObject ; Buffer : Pointeur ; BufferLength : Word) de l'objet
Cet événement sera déclenché lorsque les données seront entrées dans le tampon, où les données reçues du port série pourront être traitées. Buffer contient les données reçues et BufferLength est la longueur des données reçues.
●OnReceiveError : procédure (Expéditeur : TObject ; EventMask : DWORD)
Cet événement est déclenché lorsqu'il y a une erreur dans la réception des données.
Utilisation de SPCOMM
Ce qui suit est un exemple de communication série utilisant le contrôle SPCOMM.
En prenant comme exemple la communication entre le PC et le microcontrôleur 8051, nous devons d'abord ajuster le signal de prise de contact entre eux. Supposons que le protocole de communication entre eux est le suivant : une trame de données du PC au 8051 fait 6 octets, et une trame de données du 8051 au PC fait également 6 octets. Lorsque le PC envoie (F0,01,FF,FF,01,F0), 8051 peut recevoir une trame (F0,01,FF,FF,01,F0), indiquant que la prise de contact de communication de données est réussie, et les deux peuvent suivre les protocoles se transfèrent des données entre eux.
Créez un nouveau projet COMM.DPR, définissez la propriété NAME du formulaire sur FCOMM, définissez le titre du formulaire comme Test Communication et ajoutez les contrôles correspondants.
1. Définissez les attributs COMM1 :
● Débit en bauds : 4 800 ;
●Bit de parité : aucun ;
●Longueur d'octet : 8 ;
●Bit d'arrêt : 1 ;
●Port série : COM1.
Les données envoyées et reçues seront affichées dans Memo1. Stockez le nouveau formulaire sous Comm.pas.
2.Écrire le code source
//Description des variables
var
fcomm:TFCOMM;
chaîne d'affichage : chaîne ;
je:entier;
rbuf,sbuf:array[16] d'octets ;
//Ouvrir le port série
procédure TFCOMM.FormShow(Expéditeur : TObject);
commencer
comm1.StartComm;
fin;
//Ferme le port série
procédure TFCOMM.FormClose (Expéditeur : TObject ; var Action : TCloseAction);
commencer
comm1.StopComm;
fin;
//Personnaliser le processus d'envoi de données
procédure d'envoi de données ;
var
je:entier;
commflg:booléen;
commencer
chaîne de visualisation :='';
commflg:=true;
pour i:=1 à 6 fais
commencer
sinon fcomm.comm1.writecommdata (@sbuf[i],1) alors
commencer
commflg:=faux;
casser;
fin;
//Délai entre les octets lors de l'envoi
dormir(2);
viewstring:=viewstring＋intttohex(sbuf[i],2)+'' end;
viewstring:='Envoyer'+viewstring;
fcomm.memo1.lines.add(viewstring);
fcomm.memo1.lines.add('' );
sinon, messagedlg('L'envoi a échoué !',mterror,[mbyes],0);
fin;
//Envoyer l'événement de clic sur le bouton
procédure TFCOMM.Btn_sendClick(Expéditeur : TObject);
commencer
sbuf[1]:=byte($ f0); //En-tête du cadre
sbuf[2]:=octet($ 01); //Numéro de commande
sbuf[3]:=octet($ ff);
sbuf[4]:=octet($ ff);
sbuf[5]:=octet($ 01);
sbuf[6]:=byte($ f0); //Fin de la trame
senddata;//Appeler la fonction d'envoi
fin;
//processus de réception
procédure TFCOMM.Comm1ReceiveData (Expéditeur : TObject ; Buffer : Pointeur ; BufferLength : Word) ;
var
je:entier;
commencer
chaîne de visualisation :='';
move(buffer^,pchar(@rbuf^),bufferlength);
pour i:=1 à bufferlength faire
viewstring:=viewstring+intttohex(rbuf[i],2)+'';
viewstring:='recevoir'+viewstring;
memo1.lines.add(viewstring);
memo1.lines.add('' );
fin;
Si memo1 affiche l'envoi de F0 01 FF FF 01 F0 et la réception de F0 01 FF FF 01 F0, cela signifie que le port série a correctement envoyé et reçu des données et que la communication série est réussie.