Stackoverflow finden - wenn es denn einer ist

[himitsu]

Nja, irgendwe fing hier mit Thread an.

Zitat:

nach x minuten Absturz

Programmstarten, warten und dann einfach so peng?
(Timer?)

Oder macht der Benutzer da grade was?


Du kannst dein Programm mit Logging voll packen und dann schauen, wo dein Programm als Letztes vorbei kam und dann ab da weiter suchen.

[notAssertor]

@Medium, Knochen statt Fleisch

Schmiert das Programm auf allen PCs oder nur auf den Siemens-PCs ab?

Ist in das Programm eine Art XP-Manifest einkompiliert?

In diese beiden Richtungen würde ich zuerst rumstochern

VG

[Medium]

Zitat von notAssertor:

Schmiert das Programm auf allen PCs oder nur auf den Siemens-PCs ab?

Bisher nur auf diesen 3 Baugleichen. Auf einem anderen Panel-PC auch von Siemens in einem anderen Werk ist alles ok.

Zitat:

Ist in das Programm eine Art XP-Manifest einkompiliert?

Das werde ich mal prüfen. Gut möglich. Kann das solche seltsamen Auswirkungen haben!?

@jobo: Wie gesagt, du hast ja prinzipiell Recht. In den PCs ist meines Wissens nach zwar keine Spezialhardware, und sie gehen auch nicht in den Stromsparmodus, aber ich hetze meinen Kunden mal in diese Richtung.

@himi: Das passiert während niemand an der Kiste fummelt. Es guckt noch nichtmals einer drauf =). Feingliedriges Logging ist an sich eine gute Idee. Leider auch nur Ergebnisträchtig wenn ich hin fahre, aber das werde ich wohl als erstes tun.

[jobo]

Zitat von Medium:

In den PCs ist meines Wissens nach zwar keine Spezialhardware, und sie gehen auch nicht in den Stromsparmodus, aber ich hetze meinen Kunden mal in diese Richtung.

Also einfach mal alles was geht (BIOS, OS) auf "volle Energie", ggF. gerade / vor allem die Netzwerkkarte(>sockets>SPS).

[Helmi]

Hallo,

wenn du von Siemens-Rechner redest und diese in der Industrie sind:
Das sind aber nicht zufälligerweise Sinumerik 8x0-Anlagen mit PCU50´s?

[Medium]

@Helmi: Ne, nicht diese Monster. Wenn ich der Optik trauen darf, dann müssten das SIMATIC IPC677D sein. Zumindest sehen die im Produktkatalog dem sehr ähnlich, wenn mich mein visuelles Erinnerungsvermögen nicht völlig verlassen hat.

@naphets: TApplicationEvents habe ich noch nie eingesetzt. (Kein Grund, hab's mir einfach nie genauer angesehen.) Aber riesen Dank für die Tipps bzgl. Jedi - die habe ich immerhin schon drauf! Das probiere ich auch mal. Wobei ich nach wie vor noch immer skeptisch bei den Error-Loggern bin, da das Programm ja scheinbar außerhalb der normalen Fehlerbehandlung aussteigt.

[Helmi]

Zitat von Medium:

@Helmi: Ne, nicht diese Monster. Wenn ich der Optik trauen darf, dann müssten das SIMATIC IPC677D sein. Zumindest sehen die im Produktkatalog dem sehr ähnlich, wenn mich mein visuelles Erinnerungsvermögen nicht völlig verlassen hat.

Ich würd bei diesen Dingern etwas aufpassen - die tun so, als wären sie normale Rechner (müssten touch sein, wenn ich mich nicht täusche), sind es aber nicht
läuft da noch was anderes drauf? z. B. die WinCC-RunTime?

prüf auch mal ob alle Treiber aktuell sind (Siemens hat die Eigenart gerne mal was zu verbiegen)

vielleicht hilft dir auch das hier weiter

[nahpets]

Zitat von Medium:

@Helmi: Ne, nicht diese Monster. Wenn ich der Optik trauen darf, dann müssten das SIMATIC IPC677D sein. Zumindest sehen die im Produktkatalog dem sehr ähnlich, wenn mich mein visuelles Erinnerungsvermögen nicht völlig verlassen hat.

@naphets: TApplicationEvents habe ich noch nie eingesetzt. (Kein Grund, hab's mir einfach nie genauer angesehen.) Aber riesen Dank für die Tipps bzgl. Jedi - die habe ich immerhin schon drauf! Das probiere ich auch mal. Wobei ich nach wie vor noch immer skeptisch bei den Error-Loggern bin, da das Programm ja scheinbar außerhalb der normalen Fehlerbehandlung aussteigt.

Bei meiner eigenen Implementierung für das Jedi-Exception-Handling (oder wie es auch immer heißen mag) bekomme ich eigentlich seitdem alle Fehler mit, auch die, bei denen ich vorher das Programm eigentlich nur noch erschießen konnte (das heißt leider nicht, dass Dein Problem damit "gefangen" werden muss, aber Versuch macht kluch).

Meine "Fehlerabfangroutine" sieht so aus:

Delphi-Quellcode:

{-----------------------------------------------------------------------------
  Procedure: AppEventsException
  Date:      04.10.2012
  Arguments: Sender: TObject; E: Exception
  Result:    None
  Purpose:   Ausgabe von Fehlermeldungen.
             Diese Routine wird beim Auftreten von Exceptions aufgerufen.
-----------------------------------------------------------------------------}
procedure TSBAutoRegistry.AppEventsException(Sender: TObject; E: Exception);
Var
          sExceptionClassMessage : String;
          sDebugMessage          : String;
          sMessage               : String;
          sAddr                  : String;
          sOwner                 : String;
          dbgLocInfo             : TJclLocationInfo;
begin
  try
    // Ist Fehlerverursacher eine Komponente oder deren Nachfolger?
    if Sender is TComponent then begin
      // Hat sie einen Owner?
      if HasProperty(Sender, 'Owner') then begin
        // Dann diesen ermitteln
        sOwner := GetStrProp(Sender,'Owner');
        // und die Fehlermeldung zusammen bauen.
        sExceptionClassMessage := Format('%s, Fehlertyp: %s, Sender: %s [%s], Owner: %s',
                                        [E.Message,
                                         E.ClassName,
                                         TComponent(Sender).Name,
                                         Sender.ClassName,
                                         sOwner
                                        ]);
        // Sollen Debugfehlermeldungen erstellt werden?
        if fDebugMessages then begin
          sDebugMessage := Format('%s',[E.Message]) + #13 + #13
                         + Format('Fehlertyp: %s',[E.ClassName]) + #13
                         + Format('Sender: %s [%s]',[TComponent(Sender).Name,
                                                     Sender.ClassName]) + #13
                         + Format('Owner: %s',[sOwner]) + #13;
        end;
      end else begin
        // Es gibt keinen Owner
        // und die Fehlermeldung zusammen bauen.
        sExceptionClassMessage := Format('%s, Fehlertyp: %s, Sender: %s [%s]',
                                        [E.Message,
                                         E.ClassName,
                                         TComponent(Sender).Name,
                                         Sender.ClassName
                                        ]);
        // Sollen Debugfehlermeldungen erstellt werden?
        if fDebugMessages then begin
          sDebugMessage := Format('%s',[E.Message]) + #13 + #13
                         + Format('Fehlertyp: %s',[E.ClassName]) + #13
                         + Format('Sender: %s [%s]',[TComponent(Sender).Name,
                                                     Sender.ClassName]) + #13;
        end;
      end;
    end else begin
      // Der Fehlerverursacher ist keine Komponente oder einer ihrer Nachfolger.
      sExceptionClassMessage := Format('%s, Fehlertyp: %s, Sender: %s',
                                      [E.Message,
                                       E.ClassName,
                                       Sender.ClassName
                                      ]);
      // Sollen Debugfehlermeldungen erstellt werden?
      if fDebugMessages then begin
        sDebugMessage := Format('%s',[E.Message]) + #13 + #13
                       + Format('Fehlertyp: %s',[E.ClassName]) + #13
                       + Format('Sender: %s',[Sender.ClassName]) + #13;
      end;
    end;
  finally

  end;
  // Von der JCL genauere Fehlerinformationen ermitteln lassen
  dbgLocInfo := GetLocationInfo(ExceptAddr);
  // und diese in eine lesbare Zeichenfolge bringen lassen.
  sMessage   := GetLocationInfoStr(ExceptAddr, True, True, True, True);
  // Einen Teil davon möchten wir jedoch separat haben.
  sAddr      := Copy(sMessage,2,Pos(')',sMessage) - 2);
  // Und die Fehlermeldung in die LOG-Datei ausgeben.
  WriteAppLog(sExceptionClassMessage);
  WriteAppLog(sMessage);
  WriteAppLog(Format('Dateiname: %s',[ExtractFileName(dbgLocInfo.DebugInfo.FileName)]));
  WriteAppLog(Format('Fehleradresse: %s',[sAddr]));
  WriteAppLog(Format('Unit: %s',[dbgLocInfo.UnitName]));
  WriteAppLog(Format('Fehleradresse: %p',[dbgLocInfo.Address]));
  WriteAppLog(Format('Modulname: %s',[dbgLocInfo.SourceName]));
  WriteAppLog(Format('Prozedur: %s',[dbgLocInfo.ProcedureName]));
  WriteAppLog(Format('Prozeduroffset: %d',[dbgLocInfo.OffsetFromProcName]));
  WriteAppLog(Format('Zeilennummer: %d',[dbgLocInfo.LineNumber]));
  WriteAppLog(Format('Zeilenoffset: %d',[dbgLocInfo.OffsetFromLineNumber]));
  WriteAppLog(Format('Modul: %d [%x]',[dbgLocInfo.DebugInfo.Module, dbgLocInfo.DebugInfo.Module]));

  if fDebugMessages then begin
    // Dann hier eine entsprechende Zeichenfolge zusammenbauen.
    sDebugMessage := sDebugMessage + #13
                   + Format('Dateiname: %s',[ExtractFileName(dbgLocInfo.DebugInfo.FileName)]) + #13
                   + Format('Fehleradresse: %s',[sAddr]) + #13 + #13
                   + Format('Unit: %s',[dbgLocInfo.UnitName]) + #13
                   + Format('Fehleradresse: %p',[dbgLocInfo.Address]) + #13
                   + Format('Modulname: %s',[dbgLocInfo.SourceName]) + #13 + #13
                   + Format('Prozedur: %s',[dbgLocInfo.ProcedureName]) + #13
                   + Format('Prozeduroffset: %d',[dbgLocInfo.OffsetFromProcName]) + #13
                   + Format('Zeilennummer: %d',[dbgLocInfo.LineNumber]) + #13
                   + Format('Zeilenoffset: %d',[dbgLocInfo.OffsetFromLineNumber]) // + #13 + #13
//                 + Format('Modul: %d [%x]',[dbgLocInfo.DebugInfo.Module, dbgLocInfo.DebugInfo.Module])
//                 + Format('BinaryFile: %s',[dbgLocInfo.BinaryFileName]) + #13
                   ;
  end else begin
    sDebugMessage := e.Message;
  end;
  // Ist eine Ereignisroutine für die Fehlerausgabe... zugewiesen?
  if Assigned(fOnAppExceptionEvent) then begin
    fOnAppExceptionEvent(self,sDebugMessage);
  end else begin
    // Wenn keine Ereignisroutine für die Fehlerbehandlung zugewiesen ist,
    // geben wir hier selbst eine Fehlermeldung aus.
    MessageDlg(sDebugMessage, mtError, [mbOk], 0);
  end;
end;

Es ist die Ereignisroutine für TApplicationEvents.OnException.

Eventuell kannst Du mit Teilen davon ja was anfangen.

[nahpets]

Hast Du in dem Programm die Komponente TApplicationEvents drin (unter Delphi 7 gibt's die, bei neueren weiß ich nicht).

Zitat von Delphi7Hilfe:

Beschreibung
Mit TApplicationEvents können die Ereignisse des globalen Anwendungsobjekts Application abgefangen werden. Wenn ein TApplicationEvents-Objekt in ein Formular eingefügt wird, leitet das Anwendungsobjekt alle Ereignisse an das TApplicationEvents-Objekt weiter. Somit ist jedes Ereignis des TApplicationEvents-Objekts mit dem gleichnamigen Ereignis des Objekts Application identisch.

Jedes Formular in einer Anwendung kann ein eigenes TApplicationEvents-Objekt besitzen. Die Anwendungsereignisse treten für alle TApplicationEvents-Objekte im Projekt auf. Die Reihenfolge, in der die einzelnen TApplicationEvents-Objekte Ereignisse empfangen, kann mit der Methode Activate gesteuert werden. Wenn andere TApplicationEvents am Empfang eines bestimmten Ereignisses gehindert werden sollen, verwenden Sie die Methode CancelDispatch.

Die Komponente hat auch ein Ereignis onException, dort solltest Du dann auch die nicht von Dir abgefangenen Exceptions "abbekommen".

Um "nicht auffindbare Fehler" zu finden, nutze ich die Jedis. Dort gibt es unter \install\JVCLInstall\Debug\ einen Dialog, der die Jedi-Fehlerbehandlung kapselt.

ExceptionDlg.pas und ExceptionDlg.dfm.

(Leider nicht ganz fehlerfrei, es fehlt die Konstante AnsiCrLf = #13#10; Und die Routine

Delphi-Quellcode:

begin
  if ExceptionShowing then
    Application.ShowException(Thread.SyncException)
  else
  begin
    ExceptionShowing := True;
    try
      ShowException(Thread.SyncException, Thread);
    finally
      ExceptionShowing := False;
    end;
  end;
end;

muss geändert werden in:

Delphi-Quellcode:

class procedure TExceptionDialog.ExceptionThreadHandler(Thread: TJclDebugThread);
begin
  if ExceptionShowing then
    Application.ShowException(Exception(Thread.SyncException))
  else
  begin
    ExceptionShowing := True;
    try
      ShowException(Exception(Thread.SyncException), Thread);
    finally
      ExceptionShowing := False;
    end;
  end;
end;

Ins Programm einbinden reicht, mit ausfühlicher MAP-Datei kompilieren und diese mit ausliefern.

Ein kleines Progrämmelchen, das die Jedi-Fehlerbehandlung enthält hängt an.

Der Dialog lässt sich sicherlich so anpassen, dass das Fehlerprotokoll in eine Datei geschrieben wird, die man Dir dann ggfls. per Mail schicken könnte.