Eigene Ereignisse auslösen

[zeras]

Wie liest du denn die Daten von Async aus?
Dann kannst du dich doch nur in die Empfangsroutine mit reinhängen und dann prüfen. Von allein wird da kein Ereignis kommen.
Vielleicht hilft ein wenig Code von dir weiter.

[himitsu]

Zitat von zeras:

Dann kannst du dich doch nur in die Empfangsroutine mit reinhängen und dann prüfen. Von allein wird da kein Ereignis kommen.

Im Prinzip muß also der alte Status gespeichert sein.

Nach Empfang und Auswertung des aktuellen Records wird dessen Inhalt z.B. in sowas wie FLastCNCStatus: T_CNCStatus; gespeichert. (falls die einzelnen Statuswerte nicht schon irgendwo existieren)
Bei der Auswertung kann man nun die Alten mit den neuen Werten vergleichen und bei einem Unterschied dann das gewünschte Ereignis auslösen.

[akurka]

Hallo Himitsu,

Soviel ich in der letzte Zeit gelesen habe, soll Delphi eine Ereigniss orientierte Sprache.
Selbstverständlich kann man es mit Vergleich alt/neu
lösen, das ist sogar bereits im meinem uraltem Pascalprogramm so realisiert.
Aber ich will es ja neu schreiben.

Ich meinte, ahnlich wie die standard Ereignisse wie z.Bsp OnClick sollte man
auch eigene Ereigniss "OnChange" für die Variableaenderung definieren können.
Das wäre doch eleganter. Die Menues Umschaltung wird dann nur durch
das Ereigniss gestartete Methode bewerkstelligt.
Sollte das nicht durch überschreiben der Standard Ereignisse aus TControl
möglich sein ? Durch die Definition eines eigenen Typs ?
Nun bin ich da ein bisschen überfordert, wie es da weiter gehen soll.
Vielleicht weisst Du ein ähnliches Beispiel ?
mfg Anton

[zeras]

Überlege mal, wie man zu einem Ereignis kommt.
Man muss intern überprüfen und dann sehen, ob der Status sich geändert hat. Der beste Zeitpunkt ist, wie schon oben beschrieben, die Empfangsorutine. Die läuft ereignisgesteuert. Und da wirst du dich reinhängen müssen.
Soweit, wie ich weiß, läuft bei den RS232 Units um Hintergrund ein schneller Timer, der prüft, ob neue Daten im Hardwareempfangspuffer liegen und holt diese dann ab. Damit werden dann Ereignisse wie OnReceived etc. erstellt.
Prüfe also im Ereignis OnReceived oder ähnlich ab, ob 16 Bytes da sind und lege diese in einem separaten Puffer ab. Wenn dann wieder 16 Bytes da sind, vergleichst du dann die neuen Daten mit den Alten Daten und wenn sich der Status geändert hat, machst du dann deine Routine.

[himitsu]

Ja, Delphi ist im Grunde eine objekt-orientierte Programmiersprache (OOP), welche viel mit Events arbeitet, aber von Alleine passiert das auch nichts.

Was man machen kann, ist seinen Code in entsprechende Klassen aufzuteilen und die Events/Property entsprechend auszulegen.
Also z.B. gibt es dann irgendwo ein SMAXH-Property, welches im Setter prüft, ob sich der aktuelle Wert ändert und wenn ja, dann wird ein entsprechendes Ereignis ausgelöst.

Delphi-Quellcode:

procedure DoChange;  // hier drin wird das OnChange-Event ausgelöst 

FMyProp: Integer;
procedure SetMyProp(Value: Integer);
property MyProp: Integer read FMyProp write SetMyProp;

function GetMyPropX(Index: Integer): Integer;  // man kann auch einen Getter/Setter für mehrere Property benutzen
procedure SetMyPropX(Index, Value: Integer);
property MyPropA: Integer index 1 read GetMyPropX write SetMyPropX;
property MyPropB: Integer index 2 read GetMyPropX write SetMyPropX;
property MyPropC: Integer index 3 read GetMyPropX write SetMyPropX;

procedure TMyClass.SetMyProp(Value: Integer);
begin
  if Value = MyProp then
    Exit;
  FMyProp := Value;
  DoChange;
end;

(nun nur noch alle nötigen Werte entsprechend dieser Property-Vorlage anlegen)

[Jonas Shinaniganz]

Wenn du T_CNCStatus anfassen kannst, wovon ich ausgehe, ist folgendes denkbar:

1. Erweiterung von T_CNCStatus um Property
2. Erweiterung von T_CNCStatus um Event

Delphi-Quellcode:

type
  T_CNCStatus = packed record
  private
    FZbetr: byte;
    procedure SetZbetr(const Value: byte);
  public
    OnZbetrChange : TNotifyEvent;
    Kopf : byte;
    property Zbetr : byte read FZbetr write SetZbetr;
  end;

implementation

procedure T_CNCStatus.SetZbetr(const Value: byte);
begin
  // hier könntest du vorher überprüfen ob sich der Wert wirklich geändert hat.
  FZbetr := Value;
  if Assigned(OnZbetrChange) then
    OnZbetrChange(nil);
end;

[akurka]

Hallo Jonas, vielen Dank , das ist es, was ich gesucht habe !
Die übrige Bytes aus Status records werden zwar benötigt, aber müssen
keine ereignis auslösen. Ist es richtig, dass die Typendeklaration für Status
dann insgesamt wie folgt aussehen wird :

T_CNCStatus =packed record
private
FZbetr: byte;
procedure SetZbetr(const Value: byte);
public
OnZbetrChange : TNotifyEvent;
Kopf :byte;
Zbetr :byte;
ZREFE :byte;
FLAG :byte;
POSA1 :byte;
POSA2 :byte;
STACK :byte;
ZAUTO :byte;
ZOUT1 :byte;
ZOUT2 :byte;
ZINP1 :byte;
ZINP2 :byte;
VORSL :byte; {VORSCHUB}
VORSH :byte;
DAOUTL :byte; {DA1}
DAOUTH :byte;
SMAXH :byte;
property Zbetr : byte read FZbetr write SetZbetr;
end; {record}

mfg Anton

[akurka]

Hallo Himitsu,
danke für den Hinweis, wenn ich also Dein Beispiel auf meine
Anwendung anpasse, ist es so Richtig :

//zuerst Typendeklaration
TMyClass = procedure DoChange; // hier drin wird das OnChange-Event ausgelöst
FMyProp: Byte;
procedure SetMyProp(Value: Byte);
property MyProp: Byte read FMyProp write SetMyProp;

(* ich benötige nur ZBETR für Ereigniss auslösen, also darf ich es weglassen
function GetMyPropX(Index: Integer): Integer; // man kann auch einen Getter/Setter für mehrere Property benutzen
procedure SetMyPropX(Index, Value: Integer);
property MyPropA: Integer index 1 read GetMyPropX write SetMyPropX;
property MyPropB: Integer index 2 read GetMyPropX write SetMyPropX;
property MyPropC: Integer index 3 read GetMyPropX write SetMyPropX;
*)

Implementation
procedure TMyClass.SetMyProp(Value: Byte);
begin
if Value = MyProp then
Exit;
FMyProp := Status.ZBETR;
DoChange;
end;

[Sir Rufo]

Also an den Record selber würde ich keinerlei Events binden.

Statt dessen würde ich eine Klasse (z.B. abgeleitet von TThread ) nehmen, welche die Nachrichten empfängt und dann den gesamten Record bei einer Änderung weiterreicht.

Ein Beispiel hatte ich in einem anderen Zusammenhang schon mal geschrieben
http://www.delphipraxis.net/179188-g...a-threads.html
Das Beispiel funktioniert zwar so nicht mit Delphi 7 beschreibt aber die generelle Vorgehensweise.