Daten aus LOG-File visualisieren

[indeas]

Ich wir möchte Daten aus einem (mit einem µC erzeugten und auf SD-Karte geschrieben) Log-File visualisieren.
Es werden pro Jahr ca. 250.000 Zeilen erzeugt: Das LogFile ist so aufgebaut, alle Einträge im ASCII hex:
0000000;0F07150F33003C362C30330000FF
0000001;0F07150F34003C3A2D30330000FF
0000002;0F07150F35003C3A2F2F320000FF
....
Fortlaufende Nummer, Zeitstempel (yyMMddhhmm), dazu 4x 8Bit-Int-Werte und Statusinformationen.
Wir haben begonnen, das Thema in Visual C# 2010 Express zu bearbeiten, haben jedoch erhebliche Performance Probleme...
Letztendlich möchten wir aus diesen regelmäßig ausgelesenen Daten, einen Zeitraum (aus den gewonnenen Zeitstempeln) auswählen und diesen dann mit Charting darstellen.
Da ich kein (Windows= Programmierer bin und ich mit diesen Datenmengen keinerlei Erfahrung habe, suche ich Unterstützung.
Ich bin bereit, den Aufwand den man noch genauer abstimmen müsste zu vergüten.
Wer kann mir helfen?

[Mxt]

Hallo,

was ist den das Ziel ? Diagramme zu erhalten oder ein Programm zu schreiben ?

Wenn es darum geht Diagramme aus sehr großen Datensätzen zu extrahieren, ist eine spezielle Diagrammsoftware besser geeignet. Weit verbreitet ist z.B. Origin
http://www.originlab.com/
Das hat selber eine Makrosprache eingebaut, kann aber auch aus C# gesteuert werden.

[indeas]

Die vorhandenen Daten sollen visualisiert werden. Das funtioniert auch schon, aber eben nur sehr stockend bzw. nur bei kleinen Datenmengen vernünftig.
Habe eine Version die mit 100 Einträgen =(Zeilen) noch fertig wird, bei 500000 wird es dann zäh....
Zum Beispiel ist es problematisch (für mich) den Zeitstempel aus dem String zu erzeugen. Mit DateTimeParse dauert es bei den 500000 Zeilen ewig....
Den nächste Schritt, die Daten aus dem DataTable in eine Graph mit Zoom und dem genzen Krempel zu bringen, habe ich vor diesem Hintergrund noch gar nicht weiter verfolgt.

[Mxt]

Die vorhandenen Daten sollen visualisiert werden.
Eine wirkliche Antwort auf meine Frage ist das nicht.

Wenn man ein Programm haben will, muss man wohl erstmal ordentliche Grafikkomponenten kaufen. Mit den Bordmitteln von Visual Studio wird das sicher schwer.

Will man nur Diagramme, z.B. als PDF sollte das mit dem genannten Programm kein Problem sein. Origin kann Tabellen mit 90 Millionen Zeilen und 65000 Spalten bearbeiten. Die Programmierung ist auch auf solche Datenmengen ausgelegt und basiert auf C.
http://www.originlab.com/index.aspx?go=Products/Origin/Programming/OriginC
Man kann dort auch mit Visual C++ geschriebene DLLs einbinden.

[Unregistriert]

Hallo,

willst du es auf PC oder einem Display direkt am µC anzeigen
Das kann man ,mit dem für privaten Gebrauch kostenlosen Qlikview, machen. Uneingeschränkte Funktionalität, bis auf die Dokumentenweitergabe.
Kann ich nur empfehlen steile Lernkurve und schnelle Umsetzung solcher kleinen Auswertungen.
BIRT ginge vermutlich auch damit kenne ich mich aber nicht aus.


gruß
Macros

[indeas]

Mir ist klar, dass dies mit den C# eigenen "Bordmitteln" nur schlecht geht; habe mir mal Nevron und ZedGraph angesehen.
Jetzt suche ich aber auch noch jemanden, der die Aufgabe in Verbindung mit C# löst (gerne mit Origin, Nevron, ZedGraph,....)
Dass dieses Add-On auch Geld kostet, ist mir klar ;-)
Das ganze soll auf dem PC passieren.

[BMS]

Hallo,
würde es etwas helfen, die Daten zunächst in ein anderes Format zu konvertieren (csv, xml ... ?), wo Datum und Messwerte in einem lesbaren Format drin stünden?
Man könnte auch bestimmte Zeiträume auf mehrere Dateien aufteilen, z.B. pro Tag/Woche/Monat eine Datei, um beim Suchen nach einem Zeitraum schneller fündig zu werden.
Grüße, Bernhard

[Mxt]

Einer der Gründe für die Verlangsamung bei großen Datenmengen dürfte ineffizienter Umgang mit Strings sein. In .net sind Strings unveränderlich, wenn man das Zerlegen der Zeilen falsch macht, entstehen sehr viele Stringobjekte, die der Garbage Collector dann wieder aufräumen mus.

Ob es hier Freiberufler gibt, die solche Aufträge annehmen, bezweifle ich etwas. Aber vielleicht schaut mal jemand vorbei. Wenn das jemand macht, der sein Geld damit verdient, wird das aber nicht ganz billig.

[indeas]

Der Umgang mit Strings bremst mich gar nicht so sehr aus.
Ich kann alle Integers aus jeder der 500.000 Zeilen innerhalb <1s auslesen.
Ich kann auch die strings im Zeitstempel-Format erzeugen, auch das geht noch flott (<2s):
timestring = (year + 2000).ToString("0000") + month.ToString("00") + day.ToString("00") + hour.ToString("00") + minute.ToString("00") + "00";
Das ist nicht das zentrale Problem. Das wäre absolut OK.

Wenn ich dann aber die Zeitstempel im DateTime-Format jeder Zeile erzeugen möchte, dann wird alles langsam:
Egal ob so: TimeStamp = new DateTime(year, month, day, hour, minute, 0);
Oder aus einem aus den einzelnen Variablen zusammengesetzen string den ich dann parse, es ist dann super-langsam.

Würde gerne das DateTime Format nehmen, damit ich über eine TimeSpan nachher alles sauber selektieren kann.
Zur Visualisierung kommen wir dann erst später...Die sollte dann alle Werte zwischen zwei Zeitstempeln liefern.

Im Grunde genommen möchte ich das alles nicht unbedingt selber machen, sondern lieber jemand dafür bezahlen der so etwas kann und schon öfters gemacht hat.

[Mcgrizzly123]

Du könntest auch dem Einlesen der Daten die Umwandung in TimeStamps in mehrer Threads auslagen.

Einlesen -> (0-50.000 -> Thread 1 ) (50.000-100.000 -> Thread 2) ,...
So könnten man bei 10 Threads die Zeit auf ein Zehntel reduzieren.

[BMS]

Hallo,
es geht auch anders rum:
Den eingegebenen Zeitraum (Start, Ende) in dein ASCII-HEX Format umwandeln, in der Datei suchen (ggf. binäre Suche) und erst dann den gefundenen Teil umwandeln.
Nicht erst alles umwandeln und dann suchen...
Grüße, Bernhard

[indeas]

Zunächst vielen Dank für die Denkanstöße, allerdings: Dieser Thread steht unter Jobs/Hilfen/Stellen.
Hatte eigentlich jemanden gesucht, der das Thema gegen Bezahlung mal genauer ansehen oder bearbeiten kann.

Nachdem das nicht so richtig zündete, habe ich selber weiter gebastelt und jezt doch noch eine praktikable Lösung gefunden, die ich jetzt (nur) noch verfeinern muss:
Habe das kostenlose Tool ZedGraph eingesetzt:
Bei Zed-Graph kann man Zeitstempel mit eigenem Format (XDate) definieren, das geht dann füllen sehr schnell:
timestamp.SetDate(year, month, day, hour, minute, 0);
Damit wären die Daten schon mal sehr schnell gelesen, die Performance der anschließenden Visualisierung (mit Zoom usw.) ist auch recht ordentlich.

[fredred]

Hallo indeas,

mit einer Datenbank die LOG-Filedaten für Visualisierung bereit zu stellen, könnte ich vielleicht helfen.

Eine Datenbank hat den Vorteil alle Daten werden in einem PC-Ordner kopiert und zu gleich wird festgelegt ob alte Daten im Ordner überschrieben werden sollen oder angehängt oder nach Zeitstempelvorgabe eine neue Datei im Ordner erstellen wird(ist günstiger für Historie und Geschwindigkeit).
Das beste finde ich sind die Such– Filtereigenschaften und die vielen Auswertungen die programmiert
werden können(ein Schalterklick und schon sind die Ergebnisse zu sehen)

Bekomme ich per PN ein File, ein Monat reicht, würde ich versuchen eine kostenfreie Demo zu erstellen.
Kommen dann bestimmt noch viele Fragen und somit wird es etwas dauern bis alles stimmt.
Sollte es sehr schnell sein bin ich nicht der richtige Helfer.

PS. Beruflich(nun im verdienten Ruhestand) habe ich mit Oracle gearbeitet.
Privat mit SQL- Programmierung(ACCESS) ist zwar nicht der Platzhirsch aber für die paar Daten völlig ausreichend.
Access ist bei MS Office dabei.

Mit freundlichen Grüßen
Fred

[redround]

Guten Tag,

eine Realisierng mit C# Bordmitteln scheint mir durchaus möglich. Schließlich kann man problemlos in ein Grafic-Device "zeichnen" und damit sowohl Charts auf dem Bildschirm als auch in einem PrintDocument Objekt realisieren.

Das Einlesen der 250k Zeilen erscheint mir auch unproblematisch. Die Performance sollte auseichend sein, wenn man die Daten nach dem Einlesen in einem Array oder in einer ListOf hällt.

Grundsätzlich könnte ich die Programmierung gerne übernehmen, so lange die gewünschten Chart-Ausgaben hinreichend genau spezifiziert sind. Die Implementierung würd ich in dem Fall zum Festpreis mit Rechnungsstellung nach Abnahme durchführen. Bei Interesse würde ich mich über eine kurze PN freuen.

[Holomino]

Kannst Du mir sagen, wie lange die Ausführung des folgenden Quellcodes bei Dir dauert?


private void button1_Click(object sender, EventArgs e)
{
int Max = 500000;
Random rnd = new Random();
DateTime start = DateTime.Now;
List<DateTime> dtList = new List<DateTime>();
for (int i = 0; i < Max; i++)
{
int year = 1999;
int month = 11;
int day = 22;
int hour = 11;
int minute = 12;
int second = 13 + rnd.Next(20);
;

DateTime dt = new DateTime(year, month, day, hour, minute, second);
dtList.Add(dt);
}
System.Diagnostics.Debug.WriteLine(DateTime.Now.Su btract(start));
System.Diagnostics.Debug.WriteLine(dtList.Count);

}


Das Ergebnis siehst Du im "Direkt" oder "Immediate"-Fenster. (Menü Debug->Windows->Immediate). Bei meinem 5 Jahre alten Notebook (VS2010 mit .NET 4.0) dauert das 0,11 Sekunden.


Bezüglich der Chart-Geschichte: Es hilft, die Daten für die Ansicht so aufzubereiten, dass nicht mehr Datenpunkte eingegeben werden, als maximal auf der Bildbreite sichtbar sind. Du musst also Daten gruppieren (über Minima, Maxima zusammenfassen). Ansonsten malt das ChartControl auch nur viele vertikale Linien übereinander.

[indeas]

Habe wieder etwas gelernt: mit dem Debug-Fenster hatte noch nciht gearbeitet; habe bisher immer ein "debug"-Text-Feld in der Anwendung beschrieben, dass ich für die Endanwender dann ausgeblendet habe...

Der Code läuft sehr flott:
00:00:00.0560000
500000
Ich habe dann auch mal Teile meines Codes in die Schleife gepackt:


start = DateTime.Now;
string dummystring ="";
for (Int32 Linenumbercounter = 10; Linenumbercounter < LogFileDataLineNumbers - 2; Linenumbercounter++)
{
dummystring = LogFileDataLine[Linenumbercounter];
if (dummystring.Length == 36) // nur beschreibene Zeilen darstellen
{
try
{
LineNumber = Convert.ToInt32(dummystring.Substring(0, 7), 16);

year = int.Parse(dummystring.Substring(8, 2), NumberStyles.HexNumber) + 2000;
month = int.Parse(dummystring.Substring(10, 2), NumberStyles.HexNumber);
day = int.Parse(dummystring.Substring(12, 2), NumberStyles.HexNumber);
hour = int.Parse(dummystring.Substring(14, 2), NumberStyles.HexNumber);
minute = int.Parse(dummystring.Substring(16, 2), NumberStyles.HexNumber);
//DateTime dt = new DateTime(year, month, day, hour, minute, second);
//dtList.Add(dt);
}
catch { }
}
}
System.Diagnostics.Debug.WriteLine(DateTime.Now.Su btract(start));
System.Diagnostics.Debug.WriteLine(LineNumber);

Dann wird es schon etwas langsamer:
00:00:00.6190000
1572862
Die ganze Sache wird so richtig langsam, wenn die auskommentierten unteren beiden Zeilen in die Schleife integriere, es dauert Stunden.....
und da liegt auch das Problem, das ich durch Deinen Hinweis (Anzeige im Debug Ausgabe Fenster) gefunden habe :-)
Mein Log-File hat hin und wieder fehlerhafte Einträge (das war mir bekannt, aber ich hatte diesem Umstand keine so große Bedeutung beigemessen).
Wenn ich noch eine kleine Plausibilitätsabfrage:


if (month > 0 && month < 13 && day > 0 && day < 32 && hour < 25 && minute < 61 && year > 2014 && year < 2100)
{
DateTime dt = new DateTime(year, month, day, hour, minute, second);
dtList.Add(dt);
}

hinzufüge, dann sieht es wieder freundlich aus
00:00:00.6930693
1572862

Übrigens mit ZedGraph bringe ich alle Daten (mit Grafik) in 1,6s auf dem Schirm. Das wäre absolut OK.
Mit der Plausibilitätsabfrage sind es nur noch 1,4s das bringt dann neben Geschwindigkeit auch plausible Daten.
Danke für die Hilfe!

[Frank E.]

ICH würde die Daten zunächst einer Datenbank wie MySQL oder MariaDB einspeisen, denn die ist auf das schnelle Herauslesen, Sortieren und den Umgang mit Timestamps usw. optimiert. Das Herumstochern und Parsen irgendwelcher Strings finde ich bei dieser Datenmenge ziemlich unprofessionell ... sorry. Ein der Aufgabenstellung angepasstes SQL-Statement an die DB und DANN die Visualisierung der gefundenen Daten - so macht man das.

Falls noch Interesse an dem Auftrag besteht, ich mach' das - wahlweise für Mac, Win oder Linux mit grafischer Oberfläche. Aber im ganzen Thread wurde bisher immer noch nicht beschrieben (trotz mehrmaliger Nachfrage), was denn genau mit "Visualisierung" eigentlich gemeint ist! Ein einfaches Linien- oder Balkendiagramm oder eine virtuelle 3D-Landschaft?

[indeas]

Hallo,

Ein einfaches Liniendiagramm reicht schon. Zeitraum auswählen und dann los:
Das sieht heute ungefähr so aus:
30556
und funktioniert prinzipiell.
Das ganze soll dann noch erweitert werden, der Ansatz mit der SQL Datenbank wäre da genau das richtige...
=> Interesse besteht noch. Realisierung mit Visual C# 2010 Express, ich möchte es dann weiter pflegen können.
Erweiterung dahin gehend, dass die verschiedenen Log-Files über mehrere Jahre hintereinander zu einem Datensatz gefügt werden.
Außerdem soll noch die Darstelluung (und der Ausdruck) von fünf Alarm und Warnmeldungen in einem separtaten Text-File parallel zur Grafik möglich sein.
Also gerne nehme ich Unterstützung an. Der Auftrag ist noch nicht vergeben!

[wkrug]

Guck mal das Programm Logview www.logview.info .
Das ist speziell um Datensätze zu visualisieren.
Man kann da auch ein eigenes Open Format generieren, das nur an ein paar Konvrntionen gebunden ist.

[Frank E.]

Hallo,

Ein einfaches Liniendiagramm reicht schon. Zeitraum auswählen und dann los:
Das sieht heute ungefähr so aus:
30556
und funktioniert prinzipiell.
Das ganze soll dann noch erweitert werden, der Ansatz mit der SQL Datenbank wäre da genau das richtige... Der Auftrag ist noch nicht vergeben!

Ich kann leider nur RealBasic/Xojo (ähnlich VisualBasic, compilierte EXE bzw. APP) oder HTML/PHP/JS (Web) anbieten, mit C# o.ä. hab' ich nix am Hut ... als DB empfehle ich MariaDB, wahlweise auf dem selben PC oder "irgendwo" im LAN, z.B. falls ein NAS vorhanden ist (QNAP oder Synology), eröffnen sich da ganz neue Möglichkeiten.