RS232 Schnittstelle Daten auslesen

[M.Schultheis]

Hallo Leute,

ich weiss, die Frage bezüglich der RS232 Schnittstelle ist oftmals im Internet beantwortet.NUR, die Antworten die es da gibt, da brauch man auch gleich keine geben. Sind alle mehr oder weniger Qualitatif. Ich weiß auch das es die TSerial oder sonst was gibt! Nur läßt sich diese weder installieren, noch unfallfrei einbinden. Ich bin jetzt auf die COM-Unit von Arnold Müller gestoßen und. Die macht was ich von ihr erwarte.

Nämlich direkt und einfach die Daten ausgeben.

Was hab ich vor: Ich will die Daten von einem Mikrocontroller in dem Programm anzeigen.

Ich will aber nicht in einer endlosschleife immer die daten am port abfragen und ausgeben.
Gibts hier nicht sowas wie ein event? wenn daten am port , dann ausgabe ???

SO ähnlich wie wenn ich einen Button klicke ... da reagiert das programm ja auch von alleine.

Und glaubt mir, ich versuchs nicht erst seit gestern mit der RS232 schnittstelle oder den Komponenten Freunde zu werden.
Für eure Hilfe wäre ich echt dankbar!

Gruß Markus!

[Klaus01]

Hi Markus,

Zitat von M.Schultheis:

Ich bin jetzt auf die COM-Unit von Arnold Müller gestoßen und. Die macht was ich von ihr erwarte.
...
Gibts hier nicht sowas wie ein event? wenn daten am port , dann ausgabe ???

Du kannst ja die Abfrageroutine in einen Thread auslagern.

[edit] Vielleicht hast Du ja noch einen Link zu der Unit.
Nach Arnold Müller kann man sich ja tot googlen.

Grüße
Klaus

[haentschman]

Guten Abend,

warum landen 90 % der Beiträge #1 in "Neuen Beitrag zur Code Libary hinzufügen" ?
mag das an "Neuen Beitrag....." liegen ?



PS: Herzlich Willkommen. Nach 6 Jahren der erste Beitrag

[M.Schultheis]

Zitat von Klaus01:

Hi Markus,

...
Du kannst ja die Abfrageroutine in einen Thread auslagern.

Danke für die schnelle Antwort.... aber nächste Frage....

Hast Du n Hund ... (kleiner Scherz, is aber ein insider , Fragen wir immer wenn wir nicht weiter wissen und der Prof aufhören soll mit Input)...

WASSN N THREAD ???

Mit gefahr hats nix zu tun oder !? *scherz*

[M.Schultheis]

@haentschman: Ich geh mal von aus

[Klaus01]

Zitat von M.Schultheis:

WASSN N THREAD ???

mehr Info dazu gibt es -> TThread

Grüße
Klaus

[easywk]

Hallo zusammen,

ich setze bereits seit Jahren die Unit comdrv32.pas ein und bin damit bisher immer gut gefahren.
Das Teil stammt zwar aus dem Jahr 1997, aber bei mir gab es bisher keine Probleme damit.
Schön ist, dass es ein Receive-Event gibt.

Gruß
easy

[M.Schultheis]

Ja ... Nun habe ich mit dem Teufelszeug n bischen was getippert....

ne Type TMyThread erstellt ...
eine .execute ...


aber wo muss das ding nun rein ...
in die com unit oder in meine Form1

???

type
TMyThread = class(TThread)
private
{ Private-Deklarationen }
protected
procedure Execute; override;
end;
.
.
.
procedure TMyThread.Execute();
var c: char;
rx_buffer: string;
begin
if Port.GetChar(c)then
rx_buffer := rx_buffer + c;
form1.lstcontroller.items.add(rx_buffer);
end;
.
.
.

und hier das geistige eigentum von dem hernn müller ...
.
.
.

unit COM;

interface

uses
WinTypes, WinProcs, Classes, SysUtils;

type
TRTSMode = (RTS_DISABLED, RTS_ENABLED, RTS_HANDSHAKE, RTS_TOGGLE);
TDTRMode = (DTR_DISABLED, DTR_ENABLED, DTR_HANDSHAKE);
TParity = (NOPARITY, ODDPARITY, EVENPARITY, MARKPARITY, SPACEPARITY);
TStopbits = (ONESTOPBIT, ONE5STOPBITS, TWOSTOPBITS);
TCOM = class(TComponent)
private
FDCB: TDCB;
FHandle: Cardinal;
FTimeouts: TCommTimeouts;
FError: Cardinal;
FComNo: byte;
FBaud: word;
FParity: TParity;
FDatabits: byte;
FStopbits: TStopbits;

function GetRTS: boolean;
procedure SetRTS(const Value: boolean);
function GetDTR: boolean;
procedure SetDTR(const Value: boolean);
function GetDCD: boolean;
function GetDSR: boolean;
function GetRI: boolean;
function GetCTS: boolean;
function GetIsOpen: boolean;
function GetInBufUsed: cardinal;
function GetOutBufUsed: cardinal;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;

function TestComPortAvailable(ComNo: integer): boolean;
function Open(ComNo: integer; RTSMode: TRTSMode; DTRMode: TDTRMode): boolean;
function RxFlush: boolean;
function TxFlush: boolean;
function Send(Data: Char): boolean; overload;
function Send(Data: PChar; Len: cardinal): boolean; overload;
function GetChar(var data: Char): boolean;

procedure Close;
procedure Reset;
published
property ComNo: byte read FComNo;
property Baud: word read FBaud write FBaud;
property Databits: byte read FDatabits write FDatabits;
property Stopbits: TStopbits read FStopbits write FStopbits;
property Parity: TParity read FParity write FParity;
property IsOpen: boolean read GetIsOpen;
property InBufUsed: cardinal read GetInBufUsed;
property OutBufUsed: cardinal read GetOutBufUsed;
property Error: cardinal read FError;
property RTS: boolean read GetRTS write SetRTS;
property CTS: boolean read GetCTS;
property DTR: boolean read GetDTR write SetDTR;
property DSR: boolean read GetDSR;
property RI: boolean read GetRI;
property DCD: boolean read GetDCD;
end;

var FCOM: TCOM;

implementation


{----------------------------------------------------------------------------------------------}

constructor TCOM.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FHandle := INVALID_HANDLE_VALUE;

Baud := CBR_9600;
Databits := 8;
Parity := NOPARITY;
StopBits := ONESTOPBIT;
end;

{----------------------------------------------------------------------------------------------}

destructor TCOM.Destroy;
begin
if IsOpen then Close; { Port schließen falls geöffnet }
inherited destroy;
end;

{----------------------------------------------------------------------------------------------}

function TCOM.TestComPortAvailable(ComNo: integer): boolean;
begin
Result := Open(ComNo, RTS_DISABLED, DTR_DISABLED);
end;

{----------------------------------------------------------------------------------------------}

function TCOM.Open(ComNo: integer; RTSMode: TRTSMode; DTRMode: TDTRMode): boolean;
var init: string;
begin
if FHandle = INVALID_HANDLE_VALUE then
begin
init := '\\.\COM' + IntToStr(ComNo);
FHandle := CreateFile(@init[1],
GENERIC_READ or GENERIC_WRITE,
0, nil,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0);
if FHandle <> INVALID_HANDLE_VALUE then
begin
FComNo := ComNo;
// aktuelle Einstellungen ermitteln
if GetCommState(FHandle, FDCB) then
begin
// rudimentäre Parameter setzen
FDCB.Baudrate := FBaud;
FDCB.Bytesize := Databits;
FDCB.Parity := Ord(FParity);
FDCB.Stopbits := Ord(FStopbits);

// RTS Modus setzen
FDCB.flags := FDCB.flags and $CFFB; {RTS aus}
case RTSMode of
RTS_ENABLED: FDCB.flags := FDCB.flags or $1000; {RTS ein}
RTS_HANDSHAKE: FDCB.flags := FDCB.flags or $2004; {RTS Handshake ein (gekoppelt an RX Buffer 0= Empfangspuffer zu 3/4 voll)}
RTS_TOGGLE: FDCB.flags := FDCB.flags or $3000; {RTS gekoppelt an Tx Buffer (1=Daten im Sendepuffer)}
end;
// DTR Modus setzen
FDCB.flags := FDCB.flags and $FFC7; {DTR aus (und bleibt aus)}
case DTRMode of
DTR_ENABLED: FDCB.flags := FDCB.flags or $0010; {DTR ein (und bleibt ein)}
DTR_HANDSHAKE: FDCB.flags := FDCB.flags or $0028; {DTR Handshake ein}
end;

if SetCommState(FHandle, FDCB) then
begin
if SetupComm(FHandle, 1024, 1024) then {Rx-/Tx-Buffer-Einstellungen}
begin
FTimeouts.ReadIntervalTimeout := 0; {Timeoutzeiten setzen}
FTimeouts.ReadTotalTimeoutMultiplier := 0;
FTimeouts.ReadTotalTimeoutConstant := 1;
FTimeouts.WriteTotalTimeoutMultiplier := 0;
FTimeouts.WriteTotalTimeoutConstant := 0;
SetCommTimeouts(FHandle, FTimeouts);
end;
end;
end;
end;
end;

FError := GetLastError;

if Error <> 0 then
begin
Close;
end;

Result := Error = 0; { Ergebnis zurückgeben }
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetCTS: boolean;
var nStatus: cardinal;
begin
Result := false;
if FHandle <> INVALID_HANDLE_VALUE then
begin
if GetCommModemStatus(FHandle, nStatus) then
Result := (nStatus and MS_CTS_ON) > 0;
end;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetDSR: boolean;
var nStatus: cardinal;
begin
Result := false;
if FHandle <> INVALID_HANDLE_VALUE then
begin
if GetCommModemStatus(FHandle, nStatus) then
Result := (nStatus and MS_DSR_ON) > 0;
end;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetIsOpen: boolean;
begin
Result := FHandle <> INVALID_HANDLE_VALUE;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetInBufUsed: cardinal;
var
Comstat: _Comstat;
Errors: DWord;
begin
if ClearCommError(FHandle, Errors, @Comstat) then
Result := Comstat.cbInQue else Result := 0;
end;
{-----------------------------------------------------------------------------------------------}

function TCOM.GetOutBufUsed: cardinal;
var
Comstat: _Comstat;
Errors: DWord;
begin
if ClearCommError(FHandle, Errors, @Comstat) then
Result := Comstat.cbOutQue else Result := 0;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetRI: boolean;
var nStatus: cardinal;
begin
Result := false;
if FHandle <> INVALID_HANDLE_VALUE then
begin
if GetCommModemStatus(FHandle, nStatus) then
Result := (nStatus and MS_RING_ON) > 0;
end;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetRTS: boolean;
begin
Result := false;
if GetCommState(FHandle, FDCB) then
begin
Result := (FDCB.Flags and $3000) > 0;
end;
end;

{-----------------------------------------------------------------------------------------------}

procedure TCOM.SetRTS(const Value: boolean);
begin
if (Value = True) then
EscapeCommFunction(FHandle, WinTypes.SETRTS)
else
EscapeCommFunction(FHandle, WinTypes.CLRRTS);
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetDTR: boolean;
begin
Result := false;
if GetCommState(FHandle, FDCB) then
begin
Result := (FDCB.Flags and $0010) > 0;
end;
end;
{-----------------------------------------------------------------------------------------------}

procedure TCOM.SetDTR(const Value: boolean);
begin
if (Value = True) then
EscapeCommFunction(FHandle, WinTypes.SETDTR)
else
EscapeCommFunction(FHandle, WinTypes.CLRDTR);
end;
{-----------------------------------------------------------------------------------------------}

function TCOM.GetDCD: boolean;
var nStatus: cardinal;
begin
Result := false;
if FHandle <> INVALID_HANDLE_VALUE then
begin
if GetCommModemStatus(FHandle, nStatus) then
Result := (nStatus and MS_RLSD_ON) > 0;
end;
end;


{-----------------------------------------------------------------------------------------------}

procedure TCOM.Close;
begin
if CloseHandle(FHandle) then { Schnittstelle schließen }
FHandle := INVALID_HANDLE_VALUE;

FError := GetLastError;
end;

{-----------------------------------------------------------------------------------------------}

procedure TCOM.Reset;
begin
if not EscapeCommFunction(FHandle, WinTypes.RESETDEV) then
FError := GetLastError;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.RxFlush: boolean;
begin
if FHandle <> INVALID_HANDLE_VALUE then
begin
PurgeComm(FHandle, PURGE_RXCLEAR);
FError := GetLastError;
end;

Result := FError = 0;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.TxFlush: boolean;
begin
if FHandle <> INVALID_HANDLE_VALUE then
begin
PurgeComm(FHandle, PURGE_TXCLEAR);
FError := GetLastError;
end;

Result := FError = 0;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.Send(Data: Char): boolean;
var nWritten, nCount: Cardinal;
begin
Result := false;

if FHandle <> INVALID_HANDLE_VALUE then
begin
nCount := SizeOf(Data);
if WriteFile(FHandle, Data, nCount, nWritten, nil) then
begin
Result := nCount = nWritten;
end;
FError := GetLastError;
end;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.Send(Data: PChar; Len: cardinal): boolean;
var nWritten, nCount: Cardinal;
begin
Result := false;

if FHandle <> INVALID_HANDLE_VALUE then
begin
nCount := Len;
if WriteFile(FHandle, Data^, nCount, nWritten, nil) then
begin
Result := nCount = nWritten;
end;
FError := GetLastError;
end;
end;

{-----------------------------------------------------------------------------------------------}

function TCOM.GetChar(var data: Char): boolean;
var nCount, nRead: cardinal;
begin
Result := false;

if FHandle <> INVALID_HANDLE_VALUE then
begin
nCount := SizeOf(data);

if InBufUsed >= nCount then
begin
if ReadFile(FHandle, data, nCount, nRead, nil) then
begin
Result := nCount = nRead;
end;
end;

FError := GetLastError;
end;
end;


end.

[easywk]

Also ich würde an deiner Stelle da gar nicht mit einem Thread arbeiten. Du reisst dir da ja nur eine weitere Baustelle auf, wenn du bisher noch nicht mit Threads gearbeitet hast. Schau dir mal den ComDrv32 an. Den kannst du als Komponente installieren, packst ihn einfach auf dein Hauptformular und füllst das Empfangsevent mit Leben.

Die alte Variante, die ich benutze findet sich leider nur noch auf FTP-Servern:
ftp://ftp.fzu.cz/pub/pc/delphi/comdrv32.zip

Bei Torry findest du eine etwas neuere Variante, die auch ein Demoprogramm hat:
http://www.torry.net/pages.php?id=198

cu
easy