StringGrid mit Daten füllen und farblich Darstellen

[Jens Hartmann]

Hallo nochmal zusammen. Habe das Problem immer noch nicht beseitigen können. Hat den wirklich keiner eine Idee

Gruß

Jens

[Chemiker]

Hallo Jens Hartmann,

in welchen Takt fallen die Daten an der seriellen Schnittstelle an? Bestehet vielleicht die Möglichkeit, dass der letzte Datensatz noch nicht komplett Angezeigt wird und schon wieder ein neuer Datensatz im Buffer der Schnittstelle vorliegt.

Bis bald Chemiker

[Jens Hartmann]

Hallo Chemiker,

das kann eventuell möglich sein, die Daten schreibe ich Parallel auch in ein Memo, aber genau so wie sie kommen,

siehe Code

Delphi-Quellcode:

procedure TForm1.DatenverarbeitungMB256;
Var
  Datum              :String;
  Jahr               :String;
  Monat              :String;
  Sicherung          :String;
  Übergabe           :Integer;
  SL                 :TStringList;
  I                  :Integer;
  IA                 :Integer;
  IB                 :Integer;
  IC                 :Integer;
  ID                 :Integer;
  N                  :Integer;
begin
  Datum := DatetoStr(Date);
  Jahr := FormatDateTime('yyyy',strtodatetime(Datum));
  Monat := FormatDateTime('mmmm',strtodatetime(Datum));
  CreateDir('..\Daten\');
  CreateDir('..\Daten\'+Jahr);
  CreateDir('..\Daten\'+Jahr+'\'+Monat);

  sl := TStringList.Create;
  try
    MMUEZ2000.Lines.Add(Zeile);
    sl.AddStrings(MMUEZ2000.Lines);
    for i := 0 to sl.Count -1 do
      begin
        sl[i] := trim(StringReplace(sl[i], #$D,  '',  [rfReplaceAll]));
        sl[i] := StringReplace(sl[i], #129, 'ü', [rfReplaceAll]);
        sl[i] := trim(StringReplace(sl[i], #132, 'ä', [rfReplaceAll]));
        sl[i] := StringReplace(sl[i], #142, 'Ä', [rfReplaceAll]);
        sl[i] := StringReplace(sl[i], #148, 'ö', [rfReplaceAll]);
        sl[i] := StringReplace(sl[i], #153, 'Ö', [rfReplaceAll]);
        sl[i] := StringReplace(sl[i], #154, 'Ü', [rfReplaceAll]);
        sl[i] := StringReplace(sl[i], #10#13, ' ', [rfReplaceAll]);

      if sl[i] <> '' then
          Zeile:='';
          Memo.Lines.Append(SL[I]);
          Speichermemo.Lines.Append(SL[I]);
      end;
      MMUEZ2000.Clear;
    sl.Free;
  finally

  end;
  Zeile:='';
  Sicherung := ('..\Daten\'+Jahr+'\'+Monat+'\'+Datum+'.txt');
  Speichermemo.Lines.SaveToFile(Sicherung);
  Label1.Caption := Sicherung;
end;

In der Bufferverarbeitung sieht das ganze so aus..

Delphi-Quellcode:

begin
Laenge:=Length(Buffer);
I:=1;
while I < Laenge+1 do
                begin
                Zeile:=Zeile+Buffer[I];
                DataMB256plus:=DataMB256plus+Buffer[I];
                    case RGZentralentyp.ItemIndex of
                      0 : DatenverarbeitungMB24;
                      1 : DatenverarbeitungMB48;
                      2 : DatenverarbeitungMB100;
                      3 : DatenverarbeitungMB256;
                      4 : DatenverarbeitungUEZ2000;
                      5 : DatenverarbeitungBMC1024;
                    end;
                end;
                INC(I);

Buffer:='';
end;

Somit wird jedesmal ein fertige Zeile an die Datenverarbeitung gegeben und direkt ins Memo geschrieben.

Allerdings, Übergebe ich ja auch einen komplettten Datensatz an meine Klasse Parsen,

Hier die komplette Bufferverarbeitung

Delphi-Quellcode:

Laenge:=Length(Buffer);
I:=1;
while I < Laenge+1 do
                begin
                Zeile:=Zeile+Buffer[I];
                DataMB256plus:=DataMB256plus+Buffer[I];

                          if Buffer[I] = #13 then
                            if Buffer[I+2] = #13 then
                            begin
                            DataMB256plus := StringReplace(DataMB256plus, #154, 'Ü', [rfReplaceAll]);
                            DataMB256plus := trim(StringReplace(DataMB256plus, #$D,  '',  [rfReplaceAll]));
                            DataMB256plus:= StringReplace(DataMB256plus, #129, 'ü', [rfReplaceAll]);
                            DataMB256plus := trim(StringReplace(DataMB256plus, #132, 'ä', [rfReplaceAll]));
                            DataMB256plus := StringReplace(DataMB256plus, #142, 'Ä', [rfReplaceAll]);
                            DataMB256plus := StringReplace(DataMB256plus, #148, 'ö', [rfReplaceAll]);
                            DataMB256plus := StringReplace(DataMB256plus, #153, 'Ö', [rfReplaceAll]);
                            DataMB256plus := StringReplace(DataMB256plus, #154, 'Ü', [rfReplaceAll]);
                            DataMB256plus := StringReplace(DataMB256plus, #10#13, ' ', [rfReplaceAll]);

                            DatenverarbeitungVSTMB256plus;  //Sprung in Procedure
                            DataMB256plus := '';
                            end;

                IF Buffer[I] =#13 then
                  begin

                    case RGZentralentyp.ItemIndex of
                      0 : DatenverarbeitungMB24;
                      1 : DatenverarbeitungMB48;
                      2 : DatenverarbeitungMB100;
                      3 : DatenverarbeitungMB256;
                      4 : DatenverarbeitungUEZ2000;
                      5 : DatenverarbeitungBMC1024;
                    end;
                end;
                INC(I);
                end;

Buffer:='';
end;

Daher gesehen, Übergebe ich ja in der Var. Übergabe, die mittlerweile Data heißt ja einen kompletten Satz.

Im DF habe ich mittlerweile auch einen Thread eingestellt, in dem ich das ganze auch noch erläutert habe. Ich habe mittlerweile es soweit geschafft, das die Daten sauber im StringGrid angezeigt werden, jedoch teiilweise 3mal der gleiche Satz, und dann ein der aktuelle, allerdings die zwei dazwischen fehlen.

[EDIT]

So, habe jetzt mal den ganzen Tag Daten lesen lassen, funktioniert super, und wird auch alles eingetragen.
Mein Problem, liegt also somit woanders, und zwar, wenn ich länger keine Verbindung zur Hardware hatte, gibt es in der einen gewissen Puffer.

Dieser wird sofort Übergeben und damit hat meine Programm ein Problem, sobald der Puffer leer ist, und nur noch die Normalen Daten kommen, werden diese sauber eingefüllt. Im Anhang ist ein Bild mit so einem Anfangspuffer.

Habe ich eine Möglichkeit, das irgendwie zu lösen, Ich weiß ja jetzt auch nicht, ob es eventuell Möglich, jenachdem was da gerade an der Hardwáre passiert, wie dann die Daten kommen. Es kann ja sein, nur das kann ich halt an meiner Testanlage nicht prüfen, das es bei großen Systemen, je nach Datenaufkommen, auch schon mal zu diesem Problem kommen kann.

Mein Programm macht ja folgendes, es ließt den Puffer der Anlage, und Übergibt den an die Var. Buffer. Die Variable Buffer wird verarbeitet und anschließend wird erneut der Puffer der Zentrale ausgelesen, Auch dieser kann ja unterumständen schon wieder mehr als einen Datensatz haben.

[Chemiker]

Hallo Jens Hartmann,

ohne jede Einzelheit zu kennen mal ein paar Gedanken.

Ich würde das ganze mit einer Datenbank lösen.

1.) Ankommen Daten von der seriellen Schnittstelle sofort als Datensatz speichern. Den Datensatz mit einem TimeStamp versehen

2.) In der Regel interessieren nur die Letzten Daten, meinetwegen von der letzten Woche (Tag oder Stunden) diese wieder mir dem Programm einlesen und entsprechend Anzeigen.

Dein Konzept hat den entscheiden Nachteile, wie willst Du die Daten speichern? Selbst wenn Du Sie in einem StringGrid anzeigst so ist nach einer gewissen Datensatzanzahl der Speicher voll und der Rechner wir immer langsamer. Man müsste schon so eine Art Ringbuffer aufbauen um das Problem in den Griff zu bekommen.

Da ich selber an einem ähnlichen Programm zurzeit Arbeite, kann ich diesem Weg nur empfehlen.

Bis bald Chemiker

[Jens Hartmann]

Den Weg den ich habe, der ist der selbe.

Die Daten im String, sollen eigentlich in ein VirtualTreeView, da ich mich damit aber noch nicht so gut auskenne, aber ich momentan mit einem StringGrid.
Außerdem, werden die Daten schon in eine TXT Datei gespeichert, die folgende Struktur in einem eigenen Ordner erstellt.

D:\Daten\2009\Januar\01.01.2009.txt

Diese Dateien, brauche ich auf Kundenwusch, da diese per E-Mail täglich versendet wird.

Somit siehst du, das ich auch täglich mein Grid oder was auch immer leer mache um natürlich somit keinen Datenüberlauf zu haben.

Speicherkriterien, etc alles das ist schon in arbeit, aber eins nach dem anderen. Ich habe anfangs den Fehler gemacht viele Sachen gleichzeitig machen zu wollen, aber das ging total in die Hose.

Ich denke, das mein Konzept schon ganz gut durchdacht ist.

Der Gedanke, später mal verschieden Formate, wie eigene Datenbank, Excel und so, ist schon da.

Da ich aber noch nicht so weit mit dem Programmieren bin, befasse ich mich natürlich erst mit den sachen die ich einigermasen kann und dann schritt für schritt weiter.

Aber über Ideen und Anregungen, bin ich natürlich immer dankbar.

Gruß

Jens

[Chemiker]

Hallo Jens Hartmann,

kenn ich, so habe ich auch mit dem Programm angefangen. Auch wenn Du jetzt schon viel Arbeit in das Project investiert hast, so führt das in eine Sackgasse.

Zitat:

Zitat von Jens Hartmann

Diese Dateien, brauche ich auf Kundenwusch, da diese per E-Mail täglich versendet wird.

Auch das ist kein Problem mit einer Datenbank, aber wenn das Zeitgleich mit der Datenaufzeichnung durchgeführt werden soll, bekommst Du da schon Probleme.

Zitat:

Zitat von Jens Hartmann

Außerdem, werden die Daten schon in eine TXT Datei gespeichert, die folgende Struktur in einem eigenen Ordner erstellt.

D:\Daten\2009\Januar\01.01.2009.txt

Dann muss Du ständig die Uhrzeit abfragen ob es noch der 01.01.2009 ist oder nicht um eine genau Abgrenzung für den Tag zu bekommen.


Hier noch ein Beitrag der für Dich von Interesse sein könnte:

Link:
So schwer ist das mit einer Firebird-Datenbank nicht.

Bis bald Chemiker

[Jens Hartmann]

Alles klar,

ich werden den mal durchlesen,

wenn ich dein Argument nehme, ist das eigentlich auch mein Ziel, aber trotzallem, ändert es doch wahrscheinlich nichts daran, das die Daten immer noch nicht sauber eingtragen werden, ob ich die Daten jetzt in ein StrigGrid oder in eine Datenbank eintrage ist doch letztlich egal. Oder?

Die Daten die momnetan so ins Grid eingetragen sind, sind jedenfalss noch nicht brauchbar.

Naja, wenn ich deinen Thread gelesen habe, sehe ich das vieleicht anders.

Danke erstmal.

[Jens Hartmann]

Hallo zusammen,

mit viel Gedult und Arbeit (und Eure Hilfe) habe ich es jetzt geschaft in mein Programm einen Firebird Datenbank zu integrieren.

Leider, habe ich da genau das selbe Problem mit den Datensätze, wie mit dem StringGrid, so jetzt auch mit der Datenbank.

Es muss also definitiv an der Daten Verarbeitung beziehungsweise an der Übergabe liegen.

Vieleicht hat ja noch jemand eine Idee, wie ich das jetzt irgendwie gelößt bekomme.

[Chemiker]

Hallo Jens Hartmann,

du holst die Daten jetzt aus der Datenbank oder?

Bis bald Chemiker

[Jens Hartmann]

Nein, eben nicht.

Ich versuche die Datenbank zu füllen, und da mach er den selben Fehler, wie beim StringGrid füllen.

Schaue ich mir die Datenbank später an, ist der alte Fehler da.

Ich bin allerdings von meinen Gedanken schon etwas weiter.

Ich versuch mal es zu beschreiben.

Ich lese mit folgender Anweisung die Daten, die sich momentan im Puffer der Einbruchmeldeanlage befinden.

Delphi-Quellcode:

{Daten von COM-Schnittestelle lesen}
procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);
var
  Daten  : String;
begin
  ComPort1.ReadStr(Daten, Count);
  Buffer:=Buffer+Daten;
  Bufferverarbeitung;               //Procedure, in der die Daten verarbeitet werden
end;

Das Problem hierbei, ist das im Puffer der Einbruchmeldeanlage manchmal auch mehrere Datensätze vorhanden sind, was aber wiederum eigendlich durch die Verarbeitungsprocedure ausgeglichen werden sollte.

Delphi-Quellcode:

Procedure TForm1.Bufferverarbeitung;
Var
     I                  :Integer;
     Laenge             :Integer;
     ID                 :String;
     SatzEnd            :String;
begin
Laenge:=Length(Buffer);
I:=1;
while I < Laenge+1 do
                begin
                Zeile:=Zeile+Buffer[I];
                DataMB256plus:=DataMB256plus+Buffer[I];

                          if Buffer[I] = #13 then
                            if Buffer[I+1] = #10 then
                              if Buffer[I+2] = #13 then
                                if Buffer[I+3] = #10 then
                                  begin
                                    DataMB256plus := StringReplace(DataMB256plus, #154, 'Ü', [rfReplaceAll]);
                                    DataMB256plus := trim(StringReplace(DataMB256plus, #$D,  '',  [rfReplaceAll]));
                                    DataMB256plus:= StringReplace(DataMB256plus, #129, 'ü', [rfReplaceAll]);
                                    DataMB256plus := trim(StringReplace(DataMB256plus, #132, 'ä', [rfReplaceAll]));
                                    DataMB256plus := StringReplace(DataMB256plus, #142, 'Ä', [rfReplaceAll]);
                                    DataMB256plus := StringReplace(DataMB256plus, #148, 'ö', [rfReplaceAll]);
                                    DataMB256plus := StringReplace(DataMB256plus, #153, 'Ö', [rfReplaceAll]);
                                    DataMB256plus := StringReplace(DataMB256plus, #154, 'Ü', [rfReplaceAll]);
                                    DataMB256plus := StringReplace(DataMB256plus, #10#13, ' ', [rfReplaceAll]);

                                    DatenverarbeitungVSTMB256plus;  //Sprung in Procedure

                                    DataMB256plus := '';
                                  end;

               IF Buffer[I] =#13 then
                  begin

                    case RGZentralentyp.ItemIndex of
                      0 : DatenverarbeitungMB24;
                      1 : DatenverarbeitungMB48;
                      2 : DatenverarbeitungMB100;
                      3 : DatenverarbeitungMB256;
                      4 : DatenverarbeitungUEZ2000;
                      5 : DatenverarbeitungBMC1024;
                    end;
                end;
                INC(I);
                end;
Buffer:='';
end;

Die Frage für mich ist jetzt, wenn meine Bufferverarbeitung noch läuft, aber schon wieder ein neues Ereignis

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);

anliegt, wird der Buffer ja durch den Puffer neu gefüllt, und macht ja somit meinen Datensatz Kaputt. :gruebel:

PS: Übrigens, nenn mich ruhig Jens. :-D

[Jens Hartmann]

Schade, als ich Dir eben geantwortet habe, hatte ich eine Blitzidee, von der ich dachte Sie lößt das Problem,

Leider nicht...

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);
var
  Daten  : String;
begin
  if Buffer = '' then
  begin
  ComPort1.ReadStr(Daten, Count);
  Buffer:=Buffer+Daten;
  Bufferverarbeitung;
  end;
end;

Im Anhang mal ein Screenshot, wo du sehen kannst, das der Counter der Datenbank sauber läuft, aber Datensätze (LfdNr) fehlen.

[Chemiker]

Hallo Jens,

bis Du sicher, dass die Daten alle sauber übertragen werden?

Bis bald Chemiker

[Jens Hartmann]

Ja, das bin ich,


Ich bin noch ein Stück weiter gekommen, das Problem, liegt im Zerstören der Globalen Var. DataMB256Plus

Delphi-Quellcode:

  DataMB256plus := '';

Setze ich diese Var. in der Procedure Bufferverarbeitung auf Leer, werden Datensätze zerstört,

Setze ich diese Var. erst nach dem Eintrag in die Datenbank auf Leer, habe ich das Problem, das wenn eine Datensatz nicht richtig mit dem Wert 'Ereignis' anfängt, der Var. nie auf Leer gesetzt wird.

Das Problem, liegt darin, das wenn Du dir mal den Datensatz anschaust, sieht man das nie ein saubere Anfang und ein sauberes Ende da ist, weil die Procedure

Delphi-Quellcode:

 
{Daten von COM-Schnittestelle lesen} 
procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);

immer genau das ließt, was im Speicher ist.(Puffer der EMA).

Das heißt, das durch das Zerstören, je nach angefallenen Daten die Var. zerstört wird und somit noch nicht Übergeben Daten fehlen.

Ich trage ja nur komplette Datensätze ein, um keinen Müll in der Datenbank zu haben. Von den Daten aus dem folgenden Screenshot werden somit der erste und letzte Datensatz getilt. Liegt aber nicht am Datensatz selber, sondern daran das ich ja die Var. leere, obwohl sie noch nicht geleer werden dürfte..

Ich weiß nur echt gerade nicht, wie ich das in den Griff bekommen soll.

Am besten wäre, ich könnte schon beim einlesen nur jeweils einen Datensatzt aus dem Puffer der EMA holen. Weiß aber nicht wie oder ob es überhaupt geht.

[Chemiker]

Hallo Jens,

ich weis ich stelle blöde Fragen, aber nur um das Problem einzugrenzen.

Holst Du die Daten aus der EMA, oder werden sie von der EMA nachdem der Puffer in der EMA voll ist gesendet?

Bis bald Chemiker

[Jens Hartmann]

Nein, ich hole die Daten, der Puffer ist ja auch immer unterschielich gefüllt. Ich hole die Daten ja über meine Komponente mit dem Ereignis

Delphi-Quellcode:

{Daten von COM-Schnittestelle lesen} 
procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);

Ich weiß allerdings, leider nicht genau wann das in Kraft tritt. Aufjedenfall muss es so sein, das die Daten gehlt werden, weil die Datenmenge unterschiedlich ist.

Daher auch die diverenzen bei den Fehlenden Datensätzen. Mal alle 5 mal alle 7 ist ja unterschiedlich. Hole ich aus dem Puffer der EMA 11 Datensätze, wovon der erste und der letzte nicht vollständig sind, werden 9 in die Datenbank eingetragen. Die andern beiden entfallen.

[Chemiker]

Hallo Jens,

es muss gelingen eine Gemeinsamkeit zwischen den Datensätzen zu ermitteln.

1.) Bestehen die Datensätze immer aus der gleichen Anzahl Zeichen?
2.) Gibt es Zeichen (Zeichenreihenfolge) am Anfang des Datensatzes und am Ende?
3.) Gibt es eine gleichbleibende Zeitdifferenz zwischen den Datensätzen?

Welche Komponente benutzt Du überhaupt?

Bis bald Chemiker

[Jens Hartmann]

Ich nutzt die Komponente CPortLib (TComPort4Beta).

Ja ein Datensatz fängt immer mit 'Ereignis:' an und endet immer mit #13#10#13#10

Die einzelnen Zeilen der Datensätze sind nur mit #13#10 getrennt.

Über diese Zeichen, nehme ich den Datensatz ja auch schon auseinander. Das Problem, was ja nur da ist, das die Schnittstelle nicht bei Ereignis anfängt und bei #13#10#13#10 aufhört.

Es wird gelesen was gerade da ist.

Beispiel:

Ich lese

'atum:21.02.2009.................................. ......................
Ereignis.......................................... .......................................#13#10#13#1 0
Ereignis.......................................... .......................................#13#10#13#1 0
Ereignis.......................................... .......................................#13#10#13#1 0
Ereignis................................Extern'

Daten werden verarbeitet

Nächstes lesen

'Scharf........................................... ...
Ereignis.......................................... .......................................#13#10#13#1 0
Ereignis.......................................... .......................................#13#10#13#1 0
Ereignis.......................................... .......................................#13#10#13#1 0
Ereignis................................

Man sieht, das erste 'Extern', gehört aber noch zum 'Scharf' vom neuen lesen.

Das heißt es gehen keine Daten verloren, der Puffer wird nur nicht gleichmäßig ausgelesen.

Und da ich ja keinen Müll (Unvollständigen Datensätze) in meiner Datenbank haben möchte, entfallen somit immer der erste und letzte (Unvollständige Datensatz)

[Chemiker]

Hallo Jens,

es geht mir um folgendes, es muss ein Event gestartet werden wenn ein vollständiger Datensatz im Buffer vorhanden ist. Dieses Event muss den Datensatz abholen und den Buffer genau um diese Zeichen löschen.

Wie groß ist der Buffer?

Bis bald Chemiker

[Jens Hartmann]

Ja, so irgendwie, das Event, wäre kein Problem. Aber mir fehlen die Kenntnisse, wie ich das angehe. Wie lese ich aus der Variablen Buffer immer bis zum nächsten Datensatz, und wenn kein vollständiger mehr kommt, wieder den Puffer.

Ich denke mir das in etwa so...

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);
var
  Daten  : String;
  Satz   : String;
begin
  if Buffer = '' then                    //Durch die Abfrage ob Buffer leer ist, wird erreicht, das nicht neu gelesen wird.
  begin
    ComPort1.ReadStr(Daten, Count);
    Buffer:=Buffer+Daten;
    Bufferverarbeitung;
  end:
end;

Jetzt müsste ich aber die Var. Buffer so lange bearbeiten, bis keine Vollständiger Datensatz mehr da ist, diesen aber unvollständigen Datensatz Zwischenspeichern, danach die Var. Buffer leeren und neu einlesen. Durch die if-Abfrage beim einlesen, ist ja schonmal gewährleistet, das Buffer wirklich leer ist, bis neu gelesen wird.

Nachdem, aber Buffer neu eingelesen worden ist, muss natürlich der dann unvollständige erste datensatz natürlich wieder dem Zwischenspeicher zugeführt werden, und als erstes abgearbeitet werden.

Ich denke die Idee ist gut, aber es fehlt mir total an der Ausführung.
:gruebel:

Zitat:

Wie groß ist der Buffer?

Wie meinst Du das

[Chemiker]

Hallo Jens,

wie viel Byte passen in den Buffer, oder welcher Datentype ist Buffer.

Bis bald Chemiker

[Jens Hartmann]

Buffer ist vom Datentyp String

Delphi-Quellcode:

var
  Form1: TForm1;
  Buffer:String;
  Zeile :String;
  DataMB256plus : String;

wie die beiden anderen Globalen Var. auch

[Jens Hartmann]

Achso, der max. Datensatzgröße die aus dem Puffer gelesen werden kann, ist übrigens

1024 Byte

[Chemiker]

Hallo Jens,

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);

was wird in Count angegeben?

Bis bald Chemiker

[Jens Hartmann]

Count, ist die aktuelle Länge vom momentan vorhandene Puffer der EMA

Wenn ich z.B. folgendes in die Procedure eintrage, frage ich nur ein Zeichen aus dem Puffer ab.

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);
var
  Daten  : String;
begin
  if Buffer = '' then
  begin
  ComPort1.ReadStr(Daten, 1);  //So wird ein Zeichen gelesen
  Buffer:=Buffer+Daten;
  Bufferverarbeitung;
  end;
end;

[Chemiker]

Hallo Jens,

ich denke das Count der Buffer von der seriellen Schnittstelle ist. Welchen Wert stellst Du als Puffer für die seriellen Schnittstelle ein?

Bis bald Chemiker

[Jens Hartmann]

In der Komponente ist einen größe von 1024 Byte eingestellt.

Die Var. Buffer ist Global und vom Typ String, und für die Übergabe der Verarbeitung da.

Puffer ist keine Var. mit Puffer bezeichne ich nur die momentan in der EMA vorhandenen Daten

Dieser Puffer wird beim einlesen von der COM Schnittstelle an die Var. Buffer übergeben.

In der Anweisung habe ich nur Count stehen, was auslößt, das immer der komplett vorhandene Puffer gelesen wird

[Chemiker]

Hallo Jens,

Zitat:

Zitat von Jens

In der Anweisung habe ich nur Count stehen, was auslößt, das immer der komplett vorhandene Puffer gelesen wird

Dieses Event wird ausgelöst, wenn im Puffer von der seriellen Schnittstelle 1024 Byte vorhanden sind, nicht von der EMA, woher soll das die serielle Schnittstelle wissen?

Bei der Datensatz-Verarbeitung hast Du wahrscheinlich immer nach 1024 Byte Schwierigkeiten, weil unter Umständen zum Schluss keine vollständiger Datensatz mehr vorhanden ist.

Das bedeutet Du kannst den Buffer nicht einfach löschen, weil schon ein halber Datensatz vorhanden ist und dieser halber Datensatz würde dann mit gelöscht.
Es muss also dieser halber Datensatz irgendwie zwischen gespeichert werden und beim Auslösen des Event vor dem neuen Buffer gesetzt werden.

Bis bald Chemiker

[Jens Hartmann]

Das ist Richtig, aber wenn der Datensatz immer 1024Byte groß ist, wie kann es dann sein das er unterschiedlich lang ist.

Im Anhang, habe ich mal 2 Datensätze abgezeichnet. Es ist z.B. auch so, das beim 1 Datensatz der Count 1024 ist.

Wie bekomme ich raus, durch was das Event

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);

gestarte wird.

[EDIT] In einem anderen Thread, habe ich das hier gefunden..

Delphi-Quellcode:

Example (inside OnRxChar) 

Code: markieren 
procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer); 
var 
  Str: String; 
begin 
  ComPort1.ReadStr(Str, Count); 
  Label1.Caption := Str; 
end;

Example (outside OnRxChar)

Delphi-Quellcode:

Code: markieren 
var 
  Str: String; 
begin 
  // set timeouts here or at design time 
  ComPort1.ReadStr(Str, NumberOfBytes); 
  Label1.Caption := Str; 
end;

Sobald was an der Seriellen ankommt, wird die Caption gesetzt. Du brauchst also kein extra Button um es einzuschalten.

Jetzt musst DU nur noch einen Weg finden, bei klick auf einen Button, die Cation des Labels nicht mehr geändert werden kann.

Das müsste ja, bedeuten, wenn ich meine Ser. Schnittstelle schließe sobald ich den Buffer gelesen habe, und erste nach leerem Buffer wieder öffne, könnte es gehen.

[Chemiker]

Hallo Jens,

grade beim kleinen Buffer-Inhalt kann man sehr deutlich sehen, worauf ich hinaus will, am Anfang steht ‚ignis:…. .
Das was im Anhang ist, ist nicht der Datensatz, sondern der Buffer-Inhalt.

Das was Zwischen „Ereignis“ bis Ereignis steht ist das was Du brauchst und was einen Datensatz entspricht.

Zitat:

Zitat von Jens

Das müsste ja, bedeuten, wenn ich meine Ser. Schnittstelle schließe sobald ich den Buffer gelesen habe, und erste nach leerem Buffer wieder öffne, könnte es gehen.

Das wird wahrscheinlich nicht funktionieren, es sei denn, dass Dein Programm ein Befehl absetzt das es nicht bereit ist und zur EMA schickt.

Das sieht bisher für mich so aus, als wenn normalerweise die Events zu einem Drucker geschickt werden, dass ist auch der Grund warum Du mit einem Memo keine Schwierigkeiten hast (solange genügend Speicher für die Daten vorhanden ist).

Zu prüfen ist, ob es der EMA möglich ist die gesendeten Daten zu markieren, üblich ist das mit STX (#2) und ETX (#3). STX = Start Text ; ETX = End Text

Bis bald Chemiker

[Jens Hartmann]

Ich kann in der EMA auch die Funktion DataSafe aktivieren, allerdiings kann ich dann gar keiner Daten lesen.

Was allerdings, dann im Debugmodus zu sehen ist, das da wirklich irgendwas wie #2 und #3 erscheind.

Das Problem ist nur, da mein Programm ja flexible bleiben soll, wäre die Drucker Variante schon besser, weil ich mir da sicher bin, das alle unsere Systeme dies können, weil alle einen Druckerport haben.

Es gibt leider auch Systeme, da kann man am Drucker gar nichts programmieren, der ist vom Hersteller aus eingestellt und fertig


Das Interresante, ist ja auch, ist habe das Programm jetzt mal laufen lassen, ist normaler Betrieb, und die Daten werden nur in kleinen Mengen geliefert, Gibt es keine Problem. (Anhang Datensätze)

Das heißt, wenn ein normales Datenaufkommen vorhanden ist, werden alle Datensätze eingetragen.

[Chemiker]

Hallo Jens,

Zitat:

Zitat von Jens

Ich kann in der EMA auch die Funktion DataSafe aktivieren, allerdiings kann ich dann gar keiner Daten lesen.

Was allerdings, dann im Debugmodus zu sehen ist, das da wirklich irgendwas wie #2 und #3 erscheind.

Es ist wahrscheinlich so, dass dann #13 und #10 fehlen, man müsste dann auf #2 testen zu Anfang, dann die nachfolgenden Zeichen in den Buffer schreiben, bis #3 erkannt wird, dann hast Du ein Datensatz, nach dem speichern in der Datenbank wird der Buffer gelöscht und es geht von vorne los.

In der Drucker.gif steht in dem Protokoll, dass man auf 40 oder 80 Zeichen einstellen kann. Hast Du mal den Eingangsbuffer der serielle Schnittstelle auf diese Werte gesetzt und das Ganze mal laufen lassen?

Bis bald Chemiker

[Jens Hartmann]

Hallo Chemiker,

Also mit der Zeichenanzahl, komme ich auch nicht so richtig weiter. ich werde es mal noch mit dem Satz Anfang und Ende testen, obwohl i´ch mir auch da wenig Hoffnungen mache.

Ich habe damit heute schonmal so ein bißchen gespielt.

Ich sehe zwar bei dem Befehl ReadStr. auf der COM-Schnittstelle die #2 und #3, aber leider sonst keine Daten.

Ich werde mich aber morgen mal damit beschäftigen.

Dir und allen anderen, aber trotzdem nochmal besten Dank.

Bis dann Jens

[Jens Hartmann]

Hallo Chemiker,

also, ich habe jetzt schon den ganzen morgen an meinem Problem weitergetestet. Leider ohne Ergebnis.

Auch das mit dem Eingangspuffer auf 40 o. 80 setzten hat nichts genützt. Ich habe mal zwei Bilder vom OI Angehangen und die Hilfe der COM-Komponente.

Vieleicht hast du noch eine Idee. Vieleicht ein anderes Event, oder einfach nur eine andere Konfiguration.

Mein Englisch wird zwar besser, aber ich habe doch noch manchmal Problem, die Hilfe zu lesen. Deshalb, damit du die auch zur Verfügung hast, hänge ich die mal an.

Danke

Bis dann Jens

[Chemiker]

Hallo Jens,

die OI Ereignisübersicht kann ich nicht lesen.

Du hast noch eine zusätzlich Komponente und zwar: TComDataPacket, dort kannst Du den StartString und StopString eingeben. Dazu gibt es das Event: OnPacket. Es wird geprüft, ob der StopString angekommen ist und dann wird das Event ausgelöst. Damit sollte es eigentlich möglich sein einen isolierten Datensatz zu bekommen.

Bis bald Chemiker

[Jens Hartmann]

Danke Chemiker,

die habe ich jetzt gefunde und in meine Anwendung implementiert.

Ich habe jetzt mal versucht mit meiner Englischen Hilfe weiterzukommen.

Also wenn ich das richtig gelesen habe,

Setze ich dann den Wert StopString auf "#13#10#13#10", damit müsste geregelt sein, das das Ende
von jedem Datensatz festgelegt ist.

Dann lösche ich mein Event

Delphi-Quellcode:

procedure TForm1.ComPort1RxChar(Sender: TObject; Count: Integer);
var
Daten : String;
begin
  ComPort1.ReadStr(Daten, Count);
  Buffer := Buffer + Daten;
  Bufferverarbeitung;
end;

Und setze mein neues Event

Delphi-Quellcode:

procedure TForm1.ComDataPacket1Packet(Sender: TObject; const Str: string);
begin
  Memo.Text := 'HALLO';
end;

Allerdings, tritt das Ereignis nie ein,

Das wird aber ein Verständigungsproblem von mir sein. Leider kommt da mein schlechtes Englisch zum vorschein.

[Jens Hartmann]

Hallo Chemiker,

ich habe zumindest mal ereicht, das Event zu nutzten.

Auf den Start String Ereignis reagiert er auch, nur den Endstring (StopString) #13#10#13#10 nimmt er nicht.

Es wird immer der komplette Puffer mit 1024 Byte gelesen.

[Chemiker]

Hallo Jens,

Delphi-Quellcode:

StopString:= 'Ereignis’;

Bis bald Chemiker

[Jens Hartmann]

Das habe ich auch schon versucht, dann schreibt er aber Ereignis noch mit.

Gut das könnte ich auswerten, da ich das Wort Ereignis eh löschen.

Aber er mach es nicht immer. Manchmal, kommt dann doch sowas daraus.

[Chemiker]

Hallo Jens,

Size= 0 einstellen. Damit das Event nicht erst nach 1024 Byte ausgelöst wird.

Bis bald Chemiker

[Jens Hartmann]

Danke Chemiker für deine super Hilfe.

Es Funktioniert, so wie ich mir das Vorgestellt habe. Die Daten werden jetzt sauber in die Datenbank eingefügt.

Ich musste zwar die Bearbeitungsroutine noch anpassen um den Datensatz zu zerlegen, und den ersten nicht Vollständigen Datensatz abschneiden. Aber jetzt ist es endlich so wie es sein soll.

Und jetzt kann ich mich aller Ruhe an die anderen Zentralen geben und die entsprechenden Behandlungsroutinen der Datensätze schreiben.

Es wird ja hier keinem was nützen, wenn ich mein Projekt hier anhänge. Ohne Hardware ist das ja völlig unbrauchbar.

Aber als dankeschön an alle, werde ich in den nächsten Tagen mein Versuchsobjekt einstellen, womit jeder die Möglichkeit haben wird, Daten von einer COM-Schnittstelle zu lesen und zu verarbeiten.

Die Anpassung, kann dann jeder Projektspezifisch machen.

Besten Dank nochmal, besonders an Chemiker

Bis dann Jens