Implementierung der seriellen Kommunikation in Delphi

Implementierung der seriellen Kommunikation in Delphi

Mit der Entwicklung der modernen Informationstechnologie und der weit verbreiteten Nutzung von Computernetzwerken ist die Computerkommunikationstechnologie immer ausgereifter geworden. Als flexible, bequeme und zuverlässige Kommunikationsmethode ist sie jedoch immer noch eine effektive Kommunikationsmethode und wird in der Industrie häufig eingesetzt Kontrolle. In der industriellen Produktionspraxis erfordert die Verwendung eines PCs zur Überwachung von Projekten in Echtzeit in der Regel, dass der PC über Funktionen wie Datenerfassung, Datenverarbeitung sowie Steuersignalerzeugung und -übertragung auf der Benutzeroberfläche verfügt. Wenn in dieser speziellen Umgebung der PC mit den Echtzeitsignalen der Prozesssteuerung verbunden werden soll, ist es erforderlich, die serielle Schnittstelle des PCs direkt zu bedienen. Delphi von Borland ist eine leistungsstarke Hochprogrammiersprache mit visuellen objektorientierten Funktionen und eignet sich besonders für die Erstellung grafischer Oberflächen und Benutzerprogramme im Windows-Umfeld.

Serieller Kommunikationsmechanismus basierend auf WIN95/NT

Der Mechanismus des Windows-Betriebssystems verhindert, dass Anwendungen direkt auf Computerhardware zugreifen, stellt Programmierern jedoch eine Reihe von Standard-API-Funktionen zur Verfügung, wodurch die Anwendungsvorbereitung komfortabler wird und das Debuggen der zugehörigen Hardware entfällt. In Windows 95/NT die ursprüngliche WM_COMMNOTIFY-Nachricht von Windows 3. Arbeiten Sie einfach am Lese-/Schreibpuffer. Einige häufig verwendete Betriebsfunktionen für die serielle Kommunikation in WIN95/NT sind wie folgt:

CreatFile öffnet die serielle Schnittstelle

CloseHandle schließt die serielle Schnittstelle

SetupComm legt die Größe des Kommunikationspuffers fest

ReadFile liest den Betrieb der seriellen Schnittstelle

WriteFile schreibt den Betrieb der seriellen Schnittstelle

SetCommState legt Kommunikationsparameter fest

GetCommState ruft Standard-Kommunikationsparameter ab

ClearCommError löscht den Fehler der seriellen Schnittstelle und ruft den aktuellen Status ab

Zusätzlich zu den oben genannten Funktionen wird häufig ein wichtiger Datensatz DCB (Device Control Block) verwendet. Im DCB sind definierbare Parameter für die serielle Schnittstelle aufgezeichnet. Beim Festlegen der Parameter für die serielle Schnittstelle müssen Sie zuerst die Funktion „GetCommState“ verwenden, um die Standardwerte des Systems in den DCB-Steuerblock einzugeben, und dann die vom Benutzer festgelegten benutzerdefinierten Werte festlegen will sich ändern.

Um die serielle Kommunikation unter WIN95/NT durchzuführen, müssen Sie neben dem Verständnis der grundlegenden Kommunikationsbetriebsfunktionen auch die Multithread-Programmierung beherrschen. Ein Thread ist der Ausführungspfad innerhalb eines Prozesses und die grundlegende Einheit, die das Betriebssystem zur Zuweisung von CPU-Zeit verwendet. Jeder Prozess beginnt mit einem einzelnen Thread, um die Ausführung der Anwendung abzuschließen. Die serielle Kommunikation muss mithilfe der Multithread-Technologie implementiert werden. Die Hauptverarbeitungslogik kann wie folgt ausgedrückt werden: Zu Beginn des Prozesses führt der Hauptthread einige notwendige Initialisierungsarbeiten durch und richtet dann einen zu überwachenden Kommunikationsüberwachungsthread ein Wenn das angegebene Ereignis der seriellen Schnittstelle eintritt, wird zum richtigen Zeitpunkt eine WM_COMMNOTIFY-Nachricht an den Hauptthread gesendet (da WIN95 die WM_COMMNOTIFY-Nachricht abbricht, müssen Sie sie selbst erstellen) und der Hauptthread verarbeitet sie. Wenn die WM_COMMNOTIFY-Nachricht nicht benötigt wird, beendet der Hauptthread den Kommunikationsüberwachungsthread.

Die gleichzeitige Ausführung mehrerer Threads führt zu Konflikten auf gemeinsam genutzten Ressourcen. Um Konflikte zu vermeiden, ist es notwendig, synchronisierte Multithreads zu verwenden, um auf gemeinsam genutzte Ressourcen zuzugreifen. WIN95 bietet viele Methoden zur Aufrechterhaltung der Thread-Synchronisierung. Der Autor verwendet die Erstellung von Ereignisobjekten, um die Thread-Synchronisierung aufrechtzuerhalten. Erstellen Sie ein Ereignisobjekt über CraeteEvent() und stellen Sie das Ereignisobjekt so ein, dass es die Synchronisierung mit der Funktion etEvent() oder PulseEvent() signalisiert. Verwenden Sie in der Anwendung die Funktion WaitSingleObject(), um auf den Synchronisationsauslöser zu warten und zu warten, bis das angegebene Ereignis von anderen Threads als Signal festgelegt wird, bevor Sie mit der Ausführung des Programms fortfahren.

Spezifische Implementierungsmethode unter Delphi

Die leistungsstarken Funktionen und die objektorientierte Programmiertechnologie von Delphi, die Multithreading unterstützt, machen die serielle Kommunikation sehr einfach und bequem. Die Implementierung erfolgt durch den Aufruf externer API-Funktionen. Die Hauptschritte sind wie folgt: Erstens: Verwenden Sie die Funktion „CreateFile“, um den Besitz der seriellen Schnittstelle durch diese Anwendung zu ermitteln und zweitens zu verhindern, dass andere Anwendungen die serielle Schnittstelle betreiben. Füllen Sie den Gerätesteuerblock DCB über die GetCommState-Funktion und konfigurieren Sie dann die Baudrate, Datenbits, Paritätsbits und Stoppbits des seriellen Ports durch Aufrufen der SetCommState-Funktion. Erstellen Sie dann einen Thread zur Überwachung der seriellen Schnittstelle, um Ereignisse der seriellen Schnittstelle zu überwachen. Auf dieser Basis können Sie die Datenübertragung an der entsprechenden seriellen Schnittstelle durchführen und schließlich die CloseHandle-Funktion verwenden, um die serielle Schnittstelle zu schließen. Das spezifische Programm ist wie folgt: Dieses Programm wurde mit Delphi 3.0 kompiliert und in der Win95-Umgebung debuggt. Es wurde als Referenz für die Leser in die Praxis umgesetzt.

Programm:

Einheit Comdemou;

Schnittstelle

verwendet

Windows, Nachrichten, SysUtils, Klassen, Grafiken, Steuerelemente, Formulare, Dialoge;

const

Wm_commNotify=Wm_User+12;

Typ

TForm1 = Klasse(TForm)

PROzedur FormCreate(Sender: TObject);

Privat

Verfahren komminitialisieren;

Prozedur MsgcommProcess(Var Message:Tmessage); Message Wm_commnotify;

{Private Erklärungen}

öffentlich

{Öffentliche Erklärungen}

Ende;

//Thread-Deklaration

TComm=Klasse(TThread)

geschützt

Prozedur Execute;override;

Ende;

var

Form1: TForm1;

hcom,Post_Event:Thandle;

lpol:Poverlapped;

Durchführung

{$R *.DFM}

Prozedur TComm.Execute; //Thread-Ausführungsprozess

var

dwEvtMask:DWord;

Warten:Boolean;

Beginnen

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

While True do Begin

dwEvtMask:=0;

Wait:=WaitCommEvent(hcom,dwevtmask,lpol); //Warten auf Ereignisse der seriellen Schnittstelle;

Wenn warten, dann beginnen

waitforsingleobject(post_event,infinite); //Warten, bis das Synchronisierungsereignis festgelegt wird;

resetevent(post_event); //Synchronisationsereignis zurückgesetzt;

PostMessage(Form1.Handle,WM_COMMNOTIFY,0,0);//Nachricht senden;

Ende;

Ende;

Ende;

procedure Tform1.comminitialize; // Initialisierung der seriellen Schnittstelle

var

lpdcb:Tdcb;

Beginnen

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

file_attribute_normal oder file_flag_overlapped,0);//Öffnen Sie die serielle Schnittstelle

wenn hcom=invalid_handle_value dann

anders

setupcomm(hcom,4096,4096); //Eingabe- und Ausgabepuffer auf 4096 Bytes setzen

getcommstate(hcom,lpdcb); //Die aktuellen Standardeinstellungen des seriellen Ports abrufen

lpdcb.baudrate:=2400;

lpdcb.StopBits:=1;

lpdcb.ByteSize:=8;

lpdcb.Parity:=EvenParity; //Gerade Parität

Setcommstate(hcom,lpdcb);

setcommMask(hcom,ev_rxchar);

//Geben Sie das Ereignis der seriellen Schnittstelle als empfangene Zeichen an.

Ende;

Prozedur TForm1.MsgcommProcess(Var Message:Tmessage);

var

Clear:Boolean;

Coms:Tcomstat;

cbNum,ReadNumber,lpErrors:Integer;

Read_Buffer:array[1..100]of char;

Beginnen

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

Wenn klar, dann beginnen

cbNum:=Coms.cbInQue;

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

//Verarbeiten Sie die empfangenen Daten

SetEvent(Post_Event); //Synchronisationsereigniseinstellung

Ende;

Ende;

procedure TForm1.FormCreate(Sender: TObject);

beginnen

komminitialisieren;

post_event:=CreateEvent(nil,true,true,nil); //Erstelle ein Synchronisationsereignis;

Tcomm.Create(False); //Erstelle einen Thread zur Überwachung der seriellen Schnittstelle;

Ende;

Ende.

Name des Autors: ruan_bangqiu