# Schwingungs-/Frequenz-Anlayse



## Larry Laffer (14 Dezember 2007)

Hallo,
hat schon einmal jemand eine Schwingungs- bzw. Frequenz-Anlayse programmiert mit einer S7 ?
Ich brauche keinen Verweis auf einen Hersteller, der so etwas kann sondern nur möglicherweise schon vorhandene Erfahrungen ...

Gruß
LL


----------



## PeterEF (14 Dezember 2007)

Ich gehe mal davon aus, dass Du keine Frequenz messen willst sondern eher ein Leistungsspektrum?

Der übliche Weg auf Digitalrechnern geht dann über diskrete Fouriertransformation.

Wir haben mal sowas mit einer 300er gemacht, aber das ganze ist sehr rechenintensiv und der Kunde hat sich dann für eine Lösung auf einem abgesetzten PC entschieden, damit die SPS noch zu ihrer eigentlichen Aufgabe kam.


----------



## Larry Laffer (14 Dezember 2007)

Hallo Peter,
du hast das richtige Schlagwort genannt.
Ich nehme an, ihr habt aus der Zeit zwischen einem Anstieg an einem Abfall zwischen den Messwerten die Zeit in eine Frequenz umgerechnet und die Frequenzen gemäß der auftretenden Häufigkeiten ausgewertet. Das jedenfalls habe ich vor.
Was mich in diesem Zusammenhang interessiert ist, ob die mit der 300 eingelesenen Werte hinsichtlich der Einlese-Geschwindigkeit zu sinnvollen Ergebnissen geführt haben. Was war euer Einlese-Intervall (OB35) und über welchen Zeitraum habt ihr Werte eingelesen um zu Ergebnissen kommen zu können ? Wäre das mit der SPS erzielte Ergebnis brauchbar gewesen ? (Ich lasse dabei die Rechenzeit mal außer acht ...)

Ich bin mal gespannt auf deine Antwort ... 

Gruß
LL


----------



## zotos (14 Dezember 2007)

Wenn es um das Erfassen von Analogwerten mit einer SPS geht kann doch die Rechenzeit nicht der Knackpunkt sein. Immerhin braucht man ja eine recht große Zeit um mit den meisten SPS-Analogeingängen eine Quantitativ ausreichende Menge an Analogwerten zu erfassen.

Kannst Du die Aufgabe noch etwas genauer bzw. vereinfacht erklären?


----------



## Larry Laffer (14 Dezember 2007)

Hallo Zotos,
wir stellen in unserem Betrieb u.A. spezielle Kugellager her.
Hierbei geht es um eine Prüfung, die feststellt, ob das Lager von den Lauf-(Geräusch-)Eigenschaften OK ist. Die verwendeten Laufbahnringe haben vom Sub-Lieferanden her zum Teil Kratzer, die sich leider nicht anderweitig aufspüren lassen. Hier gibt es spezielle Prüf-Verfahren, die es ermöglichen so etwas aufzuspüren. Faktisch ist es aber nichts anderes als ein Kraftsensor mit Messverstärker und AD-Wandler.

Ich traue der SPS durchaus zu mit bis zu 200 Messungen / Sekunde (brauchbare) Werte aufzuzeichnen. Diese beinhalten Sub-Schwingungen, die es Auszuwerten gilt. Bei der Lager-Prüfung haben wir derzeit schon eine Reibmoment-Prüfung. Bei dieser glätte ich aktuell die Schwingungen heraus - ich stelle mir jedoch vor, dass die hier schon vorhandenen Schwingungen auf meinem Mess-Signal Reibmoment die Laufgeräusche der Kugeln sind. Hat nun ein Laufbahnring eine Beschädigung, dann müsste eine bestimmte Frequenz, die sich aus der Anzahl der Kugeln und dem Durchmesser des Laufbahnrings nachrechnen liesse, anwachsen - Resonanz.

Das funktioniert schon mit einem speziellen Prüfgerät (z.B. Fa. Delfin). Ich stelle mir vor, dass ich es genauso (eventuell) hinkriegen könnte ...

Und nun suche ich nach Erfahrungen diesbezüglich ...

Gruß
LL


----------



## IBN-Service (15 Dezember 2007)

Larry Laffer schrieb:


> ...
> Ich traue der SPS durchaus zu mit bis zu 200 Messungen / Sekunde (brauchbare) Werte aufzuzeichnen.
> ...
> Ich stelle mir vor, dass ich es genauso (eventuell) hinkriegen könnte ...
> ...



Hallo LL,

200 Messungen pro Sekunden erfordern aber nicht nur ne leistungsfähige
SPS sondern auch recht schnelle Analogeingänge...

Als Beispiel:
Eine "Billig" 8 - Kanal AE für die 300er hat ne Grundwandlungszeit von ca. 30ms
pro Kanal. Damit wärst du bei max. 33 Messungen / Sekunde.

Ich habe mal mit ner 300er und nem schnellen internen Analogeingang
im 1ms - Alarm ca. 1000 Messungen pro Sekunde geschafft.

Allerdings ging das mit nur einem Kanal, und die SPS (314C-2DP) war
absolut am Ende, sporadisch sprach der Weckalarm an.

Und dabei hatte die SPS sonst nichts zu tun...

Ich musste dann die Abtastrate auf 500 Hz verringern (2ms Alarm).

CU

Jürgen

.


----------



## Larry Laffer (15 Dezember 2007)

Hallo Jürgen,
ich benutze die "schnelle Analog-Karte" von Siemens "335-7HG01".
Damit kann ich schon Analogwerte in der Geschwindigkeit aufnehmen. Ich muss allerdings gestehen, dass ich bei derartigen Anwendungen gerne die 317 als CPU heranziehe. Das gibt dann keine Zeit-Probleme. Hier kann ich durchaus auch 2D-Werteketten aufzeichnen ohne das mir meine Zykluszeit "explodiert".

Mittlerweile, nachdem ich mich in die Fourier-Analyse, die PeterEF mir genannt hat, mal eingelesen habe, bin ich gar nicht mehr sicher, dass viele Werte der Weisheit letzter Schluss sind. Warscheinlich reichen 100 Messungen / Sekunde auch noch aus. Mein Problem ist im Augenblick tatsächlich die Umsetzung der FFT (schnelle Fourier-Transformation) in eine für mich verständliche Formel. Es gibt dazu zwar im Internet viel zu Lesen, aber (leider) nichts konkretes.

Hier also nochmal mein Aufruf :
(vielleicht auch an PeterEF)

Kann mir da jemand mit der FFT-Formel mit einem Programmbeispiel in Basic oder Pascal auf die Sprünge helfen ?

Gruß
LL


----------



## IBN-Service (15 Dezember 2007)

Larry Laffer schrieb:


> Kann mir da jemand mit der FFT-Formel mit einem Programmbeispiel in Basic oder Pascal auf die Sprünge helfen ?
> 
> Gruß
> LL



Hallo LL,

hab mal ne F- ANALYSE in Basic für den Sharp 1403 geschrieben.
Ähnelt dem GW - Basic.
Wenn interesse, lasse ich Sie dir per PM zukommen.

CU

Jürgen.


----------



## Oberchefe (16 Dezember 2007)

Ich würde mir mal von Wago die Klemme 750-645 anschauen, mit Profibus Koppler bekommt man die Daten in die Siemens Welt.

http://www.wago.com/wagoweb/documentation/750/ger_dat/d064500d.pdf


----------



## dalbi (17 Dezember 2007)

Schau mal hier  http://www.c-sharp-forum.de/viewtopic.php?p=398690&sid=baa97de56e7e26df9a21e8bade963e93


----------



## PeterEF (17 Dezember 2007)

Guten Morgen,

ich werde in den nächsten Tagen mal ins Archiv gucken, was noch zu finden ist.

Wir haben das damals nicht weiter verfolgt, weil die CPU (eine 314, noch die breite Bauform) mit rechnen und AE lesen/skalieren so ausgelastet war, das nichts mehr übrig blieb.
Heutzutage (z.B. Speed7-CPU mit schneller AE) sollte das besser gehen, allerdings kann man bei den Hardwarekosten dann auch gleich zu einer Lösung mit 3 Klicks und fertig greifen (z.B. Labview).


----------



## Larry Laffer (17 Dezember 2007)

@PeterEF:
Wenn du da noch etwas auftreiben könntest wäre echt toll. Ich werde parallel weiterforschen. LabView und Konsorten ist kein Thema. Auf den Gedanken bin ich gekommen, weil wir ohnehin bei unseren Lagern eine Reibmoment-Prüfung (mit der SPS) machen, die diese Kurve praktisch schon aufzeichnet - sie muß halt "nur" anders ausgewertet werden - das wäre dann der Bringer schlechthin ...

@D.Albinus:
Unter dem genannten Link findet sich nur die Auswertung der FFT. Die FFT selber ist (vorsichtshalber) nicht mit im Code enthalten. Ist aber auch so eine Sache, da ich mittlerweile auch weiß, dass Delphi ein eigenes FFT-Modul hat.

@Oberchefe:
Ich brauche keinen AD-Wandler. Den habe ich schon ...


----------



## zotos (17 Dezember 2007)

Larry Laffer schrieb:


> ...
> @Oberchefe:
> Ich brauche keinen AD-Wandler. Den habe ich schon ...



Der Link vom werten Kollegen Oberchefe führt nicht zu einem simplen Analogeingang. Diese Klemme scheint die Auswertung für Schwingungen an Wälzlagern selbst zu machen.


----------



## Larry Laffer (17 Dezember 2007)

... OK stimmt, da hast du recht.
Trifft aber trotzdem auch nicht mein Problem, da es mir in der hauptsache ja darum geht eine bereits schon aufgenommene Messkurve auf eine andere Art zu beurteilen. Die Wago-Klemme entspricht in ihrer Ausführung (plus des zusätzlich benötigten Sensors) einer einfachen Form des von uns zur Zeit experimentell eingesetzten Systems von Fa. Delfin (das genau diese schon 100mal angesprochene Fourier-Transformation intern macht).

So langsam komme ich auch hinter die Formel. Ich verstehe aber (leider) noch nicht, wie alle die Formel-Teile, die ich nun schon gesammlt habe das ausspucken (vor Allem in welcher Variablen), was man im nachstehenden Bild sehen kann :


----------



## IBN-Service (17 Dezember 2007)

Larry Laffer schrieb:


> ... OK stimmt, da hast du recht.
> Trifft aber trotzdem auch nicht mein Problem, da es mir in der hauptsache ja darum geht eine bereits schon aufgenommene Messkurve auf eine andere Art zu beurteilen. Die Wago-Klemme entspricht in ihrer Ausführung (plus des zusätzlich benötigten Sensors) einer einfachen Form des von uns zur Zeit experimentell eingesetzten Systems von Fa. Delfin (das genau diese schon 100mal angesprochene Fourier-Transformation intern macht).
> 
> So langsam komme ich auch hinter die Formel. Ich verstehe aber (leider) noch nicht, wie alle die Formel-Teile, die ich nun schon gesammlt habe das ausspucken (vor Allem in welcher Variablen), was man im nachstehenden Bild sehen kann :



Hallo LL,

die obere Linie zeigt ja den Kurvenverlauf, aus dem du (mit möglichst kleinem Intervall)
deine Stützpukte messen musst.
Die sich ergebenden Sinusschwingungen (Harmonischen?) werden in der unteren Linie angezeigt.

Das Analyse - Programm könnte dir vielleicht dabei behilflich sein,
eben diese Harmonische aus den Stützpunkten herauszurechnen.

Noch was, da du dich ja mit Pascal auskennst, würde ich die letztendliche Formel
auf jeden Fall in SCL codieren.

CU

Jürgen

.


----------



## Larry Laffer (17 Dezember 2007)

Hallo Jürgen,
so ist es gedacht ...

Eine Messung bei mir könnte so aussehen, wie auf dem dargestellten Bild. Die Frequenzen, die ich suche ergeben sich aus dem Laufbahn-Durchmesser, auf der die Kugeln laufen, der Anzahl der Kugeln und der Drehzahl bei der Messung. Hier sollte die Amplitude der Suchfrequenz normalerweise klein sein und nur bei Beschädigung der Laufbahn einen deutlichen Ausschlag erbringen.

Nun das Problem, dass ich immer noch nicht hinreichend gelösst habe :
Mein ARRAY_of_Messpunkte (_INT) wird aktuell erstellt in der S7 im OB35 mit einer momentanen Abtastung von 100Hz (alle 10 ms). Wie fügen sich nun die erfassten Y-Werte und die aus der Abtastung resultierenden X-Werte (Index * 10 ms) in die Berechnungs-Formel ein ? Das habe ich leider noch nicht gecheckt ...

Gruß
LL


----------



## kiestumpe (17 Dezember 2007)

BTW:In welchem Bandbereich erwartest du das Signal?


----------



## Larry Laffer (17 Dezember 2007)

...
in etwa im Bereich von 10 bis 60 Hz. Warum ?


----------



## kiestumpe (17 Dezember 2007)

Weil du mit 100Hz Abtastfrequenz kein 60Hz-Signal mehr vernünftig abtasten kannst! Entweder musst du dann auf min. 120Hz gehen,  oder einen Tiefpass noch einbauen.


----------



## Larry Laffer (17 Dezember 2007)

...?
Ich hatte weiter vorne im Thread bereits erwähnt, dass ich vorhabe im Erfolgsfall meine Abtastrate auf 200 Hz (5 ms) zu erhöhen .



> Beitrag Nr.5 :
> Ich traue der SPS durchaus zu mit bis zu 200 Messungen / Sekunde (brauchbare) Werte aufzuzeichnen.


----------



## kiestumpe (17 Dezember 2007)

Naja, hauptsache du weisst was du letzlich willst, weil weiter im Thread hat es wieder anders geklungen:

Mittlerweile, nachdem ich mich in die Fourier-Analyse, die PeterEF mir genannt hat, mal eingelesen habe, bin ich gar nicht mehr sicher, dass viele Werte der Weisheit letzter Schluss sind. Warscheinlich reichen 100 Messungen / Sekunde auch noch aus. Mein Problem ist im Augenblick tatsächlich die Umsetzung der FFT (schnelle Fourier-Transformation) in eine für mich verständliche Formel. Es gibt dazu zwar im Internet viel zu Lesen, aber (leider) nichts konkretes.


----------



## Larry Laffer (17 Dezember 2007)

...
schön, dass du mich darauf hinweisst ...
Leider ist es aber auch gar nicht mein Problem (im Augenblick). Darüber hinaus hat die Fourier-Transformation (im ersten Moment) gar nichts mit der Signal-Abtastung zu tun. Es werden Misch-Frequenzen auseinander-gefiltert. Leider haber ich da vorhin nicht schnell genug geschaltet.

Mal sehen, wie es weiter geht ...


----------



## PeterEF (18 Dezember 2007)

Larry Laffer schrieb:


> ...
> schön, dass du mich darauf hinweisst ...
> Leider ist es aber auch gar nicht mein Problem (im Augenblick). Darüber hinaus hat die Fourier-Transformation (im ersten Moment) gar nichts mit der Signal-Abtastung zu tun. Es werden Misch-Frequenzen auseinander-gefiltert.


 
Naja - doch: wenn Du vermutest, das dein Mischsignal u.a. ein Signal mit der Frequenz 60 Hz enthält, solltest Du schon mit 120 Hz abtasten, um das auch mitzukriegen.

Ich bin unter Staub und Spinnweben fündig geworden:
K.D.Kammeyer / K.Kroschel: "Digitale Signalverarbeitung - Filterung und Spektralanalyse" ; Teubner Studienbücher Elektrotechnik ; Stuttgart 1989 ; ISBN 3-519-06122-8 ; hier besonders die Seiten 166ff.

Falls das Buch in der Bibliothek Deines Vertrauens nicht vorrätig ist, kann ich heute abend mal den Scanner anschmeißen, oder läufts schon?

Schönen Tag!


----------



## Larry Laffer (18 Dezember 2007)

Hallo Peter,
Das Buch ist in der "BmV" nicht vorhanden.
Wenn du da ein paar brauchbare Sachen hast, dann bin ich immer noch interessiert. Ich bin mit meinem Puzzle zwar schon etwas weiter, aber der Durchbruch fehlt noch.

Gruß
LL


----------



## PeterEF (18 Dezember 2007)

Wenn Du mir eine EMail-Adresse zukommen lassen kannst, die Anhänge verkraftet, hast Du es morgen früh in der Post.....


----------



## Kai (18 Dezember 2007)

Mit Hilfe der folgenden Formeln kann man die Fourier-Koeffizienten einer reellen periodischen Zeitfunktion und die entsprechenden Frequenzanteile des Amplituden und Phasenspektrums berechnen. Eine Periode der Funktion ist dabei durch eine beliebig vorgebbare gerade oder ungerade Zahl äquidistanter Stützstellen definiert.

Gruß Kai


----------



## Larry Laffer (24 Dezember 2007)

*... geschafft ...*

...
noch kurz vor Weihnachten :
Dank reger Beteiligung an diesem Thread von :
*Zotos* . *IBN-Service* und *PeterEF* ist es mir gelungen auf Excel-Basis einen ersten Ansatz zu dem genannten Thema zu erstellen. Wie ich allen versprochen habe, werde ich nun zunächst mal dieses Werk für alle, die Interesse haben (und das waren ja nun doch schon einige gewesen) hier einstellen.

Ich hoffe natürlich auf weitere Beteiligung au dem Thema. Auch *Kai *hat mir schon einen Beitrag zu dem Thema "angedroht" ...
Ich bin einmal gespannt, was daraus noch wird ...

Wie auch immer, allen Beteiligten an diesem Thread (und natürlich auch allen anderen) ein schönes Weihnachtsfest.

Gruß
LL


----------



## Kai (28 Dezember 2007)

Hier nun ein Programmbeispiel für die DFT Diskrete Fourier-Transformation:



> DFT DISKRETE FOURIER-TRANSFORMATION
> 
> Aus den Werten einer periodischen Zeitfunktion werden die Fourier-Koeffizienten AK und BK und die entsprechenden Frequenzanteile des Amplitudenspektrums CK und des Phasenspektrums PK berechnet.
> 
> Die Periode der Funktion ist durch eine beliebig vorgebbare gerade oder ungerade Zahl äquidistanter Stützstellen N vorgeben.


 

```
FUNCTION FC200 : VOID
TITLE = 'DFT Diskrete Fourier-Transormation'
 
//**************************************************
//DFT DISKRETE FOURIER-TRANSFORMATION
//
//Aus den Werten einer periodischen Zeitfunktion
//werden die Fourier-Koeffizienten AK und BK und
//die entsprechenden Frequenzanteile des 
//Amplitudenspektrums CK und des Phasenspektrums PK
//berechnet.
//
//Die Periode der Funktion ist durch eine beliebig
//vorgebbare gerade oder ungerade Zahl äquidistanter
//Stützstellen N vorgeben.
//**************************************************
 
NAME    : FOURIER
FAMILY  : SPSFORUM
AUTHOR  : KAI
VERSION : '1.0'
 
VAR_INPUT
    Y     : ARRAY[0..400] OF REAL;    // Werte Y
    N     : INT;                      // Anzahl Intervalle
    FK    : INT;                      // Anzahl Fourier-Koeffizienten
END_VAR
 
VAR_OUTPUT
    CK    : ARRAY[0..200] OF REAL;    // Amplitudenspektrum CK
    PK    : ARRAY[0..200] OF REAL;    // Phasenspektrum PK
END_VAR
 
VAR_TEMP
    AK    : REAL;                     // Fourier-Koeffizient AK
    BK    : REAL;                     // Fourier-Koeffizient BK
    PI    : REAL;                     // Pi
    FKMAX : INT;                      // Maximale Anzahl Fourier-Koeffizienten
    K     : INT;                      // Schleifenzähler
    J     : INT;                      // Schleifenzähler
    S     : INT;                      // Vorzeichen
END_VAR
 
BEGIN
 
//**************************************************
//Initialisierung
//**************************************************
 
PI := 3.14159265;
 
FOR K := 0 TO 200 DO
    CK[K] := 0;
    PK[K] := 0;
END_FOR;
 
//**************************************************
//Maximale Anzahl Fourier-Koeffizienten FKMAX
//**************************************************
 
FKMAX := DINT_TO_INT(ROUND(N/2));
 
IF FK < FKMAX THEN
    FKMAX := FK;
END_IF;
 
//**************************************************
//Fourier-Koeffizienten CK, PK
//**************************************************
 
FOR K := 1 TO FKMAX DO
    AK    := 0;
    BK    := 0;
    FOR J := 0 TO (N-1) DO
        AK := AK + Y[J]*COS(2*PI/N*K*J);
        BK := BK + Y[J]*SIN(2*PI/N*K*J);
    END_FOR;
    AK := AK*2/N;
    BK := BK*2/N;
    CK[K] := SQRT(SQR(AK) + SQR(BK));
    PK[K] := ATAN(BK/AK);
END_FOR;
 
//**************************************************
//Fourier-Koeffizient C0
//**************************************************
 
K  := 0;
AK := 0;
 
FOR J := 0 TO (N-1) DO
    AK := AK + Y[J];
END_FOR;
 
AK    := AK/N;
CK[K] := AK;
 
//**************************************************
//Fourier-Koeffizient CMAX
//**************************************************
 
IF FKMAX = (N/2) THEN
    AK := 0;
    S  := -1;
    FOR J := 0 TO (N-1) DO
        S  := -S;
        AK := AK + S*Y[J];
    END_FOR;
END_IF;
 
AK        := AK/N; 
CK[FKMAX] := AK;  
 
END_FUNCTION
```
 
Gruß Kai


----------



## Kai (28 Dezember 2007)

Eine Anwendung der DFT Diskreten Fourier-Transformation auf die Funktion aus dem EXCEL-Beispiel von Larry Laffer zeigt eine sehr gute Übereinstimmung im Amplitudenspektrum CK.



> F1 = 1 Hz => M1 = 1,00 Nm
> 
> F2 = 10 Hz => M2 = 3,00 Nm
> 
> ...


Gruß Kai


----------



## Larry Laffer (29 Dezember 2007)

Hallo Kai,
dein SCL-Beispiel zur DFT habe ich mir sofort einmal heruntergeladen.
Über die DFT bin ich auch häufig "gestolpert", habe im Internet aber nirgends ein für mich verständliches Beispiel gefunden. Danke also, dass du mich um die Geschichte nun auch bereichert hast. Ich werde das gleich mal in Excel umsetzen.

Gibt es deiner Ansicht nach zwischen der FFT und der DFT hinsichtlich Genauigkeit oder Ähnlichem größere Unterschiede ? 

Ich danke dir in jedem Fall für deinen Beitrag. Er war, wie alle anderen deiner Beiträge, die ich bislang so begutachten durfte, wieder wie nicht anders gewohnt. große Klasse. 

Gruß
LL


----------



## Larry Laffer (30 Dezember 2007)

@Kai:
ich habe jetzt anlehnend an dein SCL-Script die ganze Geschichte noch mal in Excel-VBA nachvollzogen. In dem Zusammenhang gleich eine Frage:
Worin besteht der wesentliche Unterschied zwischen den biden Variablen "N" und "FK", da sie doch anscheinend den gleichen Wert haben müssen ?
...
Und noch etwas: Da du das Ganze ja als SPS-Programm erstellt hast ... Kannst du Aussagen zur Abarbeitungszeit des Bausteins machen bei z.B. 512 Quell-Variablen ? Selber bin ich noch nicht soweit und das wirdauch bestimmt vor Ende nächster Woche noch nichts werden ...

Gruß
LL


----------



## Kai (30 Dezember 2007)

Larry Laffer schrieb:


> Gibt es deiner Ansicht nach zwischen der FFT und der DFT hinsichtlich Genauigkeit oder Ähnlichem größere Unterschiede ?


 
So genau weiß ich das auch nicht, ich denke aber, dass die Unterschiede zwischen der DFT und der FFT hinsichtlich der Genauigkeit eher gering sind.

Ansonsten hat jede Berechnungsmethode ihre Vor- und Nachteile:

Die DFT hat gegenüber der FFT den Vorteil, dass bei der DFT die Anzahl der Abtastpunkte des Signals beliebig sein kann, während bei der FFT die Anzahl der Abtastpunkte einer Zweierpotenz entsprechen muss, also 1, 2, 4, 8, 16, 32 usw.

Dafür ist die FFT bei der Berechnung der Werte der Fourier-Transformation um einiges schneller als die DFT und sollte bei größeren Datenmengen eher angewendet werden.



Larry Laffer schrieb:


> Ich danke dir in jedem Fall für deinen Beitrag. Er war, wie alle anderen deiner Beiträge, die ich bislang so begutachten durfte, wieder wie nicht anders gewohnt, große Klasse.


 
Danke schön. :-D 

Gruß Kai


----------



## Kai (30 Dezember 2007)

Larry Laffer schrieb:


> Worin besteht der wesentliche Unterschied zwischen den biden Variablen "N" und "FK", da sie doch anscheinend den gleichen Wert haben müssen ?


 
Es gilt folgendes:



> *DFT:*
> 
> N = Anzahl Datenpunkte (Abtastpunkte)
> 
> ...


Mit N gibt man also vor, wie viele Messwerte man hat, und mit FK gibt man vor, wie viele Fourier-Koeffizienten berechnet werden sollen. FK muss dabei <= FKMAX sein.



> Beispiel:
> 
> N = 256 Datenpunkte
> 
> ...


 


Larry Laffer schrieb:


> Und noch etwas: Da du das Ganze ja als SPS-Programm erstellt hast ... Kannst du Aussagen zur Abarbeitungszeit des Bausteins machen bei z.B. 512 Quell-Variablen ?


 
Was für eine CPU willst Du denn einsetzen?

Gruß Kai


----------



## Larry Laffer (31 Dezember 2007)

Hallo Kai,
Danke für die Erläuterung. "N" für Anzahl war schon klar gewesen, "FK" eben nicht. Ich hatte erst der Vermutung aufgesessen, dass es Wiederholungen sein könnten, aber das hatte dann ja auch nicht gefunzt. Jetzt ist es klar ...

Als CPU stelle ich mir eine 317 vor. Ich denke, die kriegt das hin. Würde mich halt nur mal interessieren, wie lang ein Zyklus wird, wenn der Baustein läuft. Hintergrund :





> von *PeterEF*: Wir haben mal sowas mit einer 300er gemacht, aber das ganze ist sehr rechenintensiv und der Kunde hat sich dann für eine Lösung auf einem abgesetzten PC entschieden, damit die SPS noch zu ihrer eigentlichen Aufgabe kam.


Ein hoch-Puschen der Zykluszeit über 750 ms hinaus würde mich nicht so sehr schocken, da es ja nicht ständig wäre. Außerdem habe ich noch einen anderen netten Auswerte-Baustein in einer anderen Anwendung, der das auch kann ...

Gruß
LL


----------



## zotos (31 Dezember 2007)

Larry Laffer schrieb:


> ...
> Als CPU stelle ich mir eine 317 vor. Ich denke, die kriegt das hin. Würde mich halt nur mal interessieren, wie lang ein Zyklus wird, wenn der Baustein läuft.
> ...
> Ein hoch-Puschen der Zykluszeit über 750 ms hinaus würde mich nicht so sehr schocken, da es ja nicht ständig wäre.
> ...



Das mit der Zykluszeit erinnert mich an die Aufgabenstellung von Steve81. Auch hier würde ich, bevor die Zykluszeit aus dem Ruder läuft, den Algorithmus auf mehrere SPS-Zyklen Aufteilen. 
Der Code von Kai lässt sich ja recht einfach in Sequenzen aufteilen die man mit einer Case Verzweigung ansteuern kann. Auch die Schleifen kann man auf mehrere SPS-Zyklen verteilen.
Natürlich müssen die Variablen statisch sein. 

Hier mal der Code wie das aussehen könnte:

```
//**************************************************
//DFT DISKRETE FOURIER-TRANSFORMATION
//
//Aus den Werten einer periodischen Zeitfunktion
//werden die Fourier-Koeffizienten AK und BK und
//die entsprechenden Frequenzanteile des 
//Amplitudenspektrums CK und des Phasenspektrums PK
//berechnet.
//
//Die Periode der Funktion ist durch eine beliebig
//vorgebbare gerade oder ungerade Zahl äquidistanter
//Stützstellen N vorgeben.
//**************************************************
 
NAME    : FOURIER
FAMILY  : SPSFORUM
AUTHOR  : KAI
VERSION : '1.0'
 
VAR_INPUT
    START : BOOL;    
    Y     : ARRAY[0..400] OF REAL;    // Werte Y
    N     : INT;                      // Anzahl Intervalle
    FK    : INT;                      // Anzahl Fourier-Koeffizienten
END_VAR
 
VAR_OUTPUT
    CK    : ARRAY[0..200] OF REAL;    // Amplitudenspektrum CK
    PK    : ARRAY[0..200] OF REAL;    // Phasenspektrum PK
    BUSY  : BOOL;                     // Algorithmus läuft            
END_VAR
 
VAR
    AK    : REAL;                     // Fourier-Koeffizient AK
    BK    : REAL;                     // Fourier-Koeffizient BK
    PI    : REAL;                     // Pi
    FKMAX : INT;                      // Maximale Anzahl Fourier-Koeffizienten
    K     : INT;                      // Schleifenzähler
    J     : INT;                      // Schleifenzähler
    S     : INT;                      // Vorzeichen
    STEP  : INT;                      // Sequenser
    CYCLE : INT;                      // Wiederholungen im SPS-Zyklus
    PULSE : BOOL;                     // Sequenser takten
END_VAR
 
BEGIN

//**************************************************
//PULSE & CYCLE
//************************************************** 
IF PULSE THEN
  STEP := STEP + 1;
END_IF;

CYCLE := 0; // Neuer SPS Zyklus


CASE STEP OF 
0:; //**************************************************
    //Start
    //************************************************** 
      BUSY := START;
      PULSE := START;
      
1:; //**************************************************
    //Initialisierung
    //**************************************************         
    IF PULSE THEN
      PI := 3.14159265;
      K  := 0;
      PULSE := FALSE;
    ELSE    
      WHILE CYCLE < 50 AND NOT PULSE DO 
        CK[K] := 0;
        PK[K] := 0;


        CYCLE := CYCLE + 1;
        PULSE := K >= 200;
        K  := K + 1;        
      END_WHILE;
    END_IF; 
2:; //**************************************************
    //Maximale Anzahl Fourier-Koeffizienten FKMAX
    //************************************************** 
    FKMAX := DINT_TO_INT(ROUND(N/2));
 
    IF FK < FKMAX THEN
        FKMAX := FK;
    END_IF;
 
3:; //**************************************************
    //Fourier-Koeffizienten CK, PK
    //************************************************** 
    IF PULSE THEN
      K  := 1;
      PULSE := FALSE;
    ELSE    
      WHILE CYCLE < 10 AND NOT PULSE DO 
        AK    := 0;
        BK    := 0;
        FOR J := 0 TO (N-1) DO
            AK := AK + Y[J]*COS(2*PI/N*K*J);
            BK := BK + Y[J]*SIN(2*PI/N*K*J);
        END_FOR;
        AK := AK*2/N;
        BK := BK*2/N;
        CK[K] := SQRT(SQR(AK) + SQR(BK));
        PK[K] := ATAN(BK/AK);

  
        CYCLE := CYCLE + 1;
        PULSE := K >= FKMAX;
        K  := K + 1;              
      END_WHILE;
    END_IF;
    
4:; //**************************************************
    //Fourier-Koeffizient C0
    //************************************************** 
    IF PULSE THEN
      K  := 0;
      AK := 0;
      J  := 0;
      PULSE := FALSE;
    ELSE    
      WHILE CYCLE < 40 AND NOT PULSE DO 
        AK := AK + Y[J];

        CYCLE := CYCLE + 1;
        PULSE := J >= N-1;
        J  := J + 1;                
      END_WHILE;
    END_IF; 
    IF J >= N-1 THEN      
      AK    := AK/N;
      CK[K] := AK;
    END_IF;
 
5:; //**************************************************
    //Fourier-Koeffizient CMAX
    //************************************************** 
    IF FKMAX = (N/2) THEN
      AK := 0;
      S  := -1;
      FOR J := 0 TO (N-1) DO
          S  := -S;
          AK := AK + S*Y[J];
      END_FOR;
    END_IF;
 
    AK        := AK/N; 
    CK[FKMAX] := AK;  

6:; //**************************************************
    //Ende der Show
    //************************************************** 
    STEP  := 0;
    CYCLE := 0;
    PULSE := FALSE;
    BUSY  := FALSE;
ELSE
  //Fehler********************************************** 
  STEP  := 0;
  CYCLE := 0;
  PULSE := FALSE;
  BUSY  := FALSE;  
END_CASE;
 
END_FUNCTION_BLOCK
```
Man sollte noch sicherstellen das sich die Eingangsvariablen nicht ändern solange der FB Busy ausgibt bzw. bei der Initialisierung das ganze in den STAT Bereich sichern.


----------



## Larry Laffer (1 Januar 2008)

Danke für den Vorschlag. Hatte ich auch schon erwogen, aber dann auch wieder verworfen. Selbst wenn die Zykluszeit in dem Auswerte-Zyklus extrem ansteigt wird sie sich in meinem Restprogramm auf die dann laufenden Aktionen nur wie eine zusätzliche (aber unnötige) Nachlaufzeit auswirken. Die Station, die diese Analyse machen wird, muss wie alle anderen Stationen meiner Anlage, von denen die meißten gleichzeitig laufen, fertig sein, damit es weitergehen kann.

Aber erstmal muss es jetzt diese Station überhaupt geben ...


----------



## Larry Laffer (10 Januar 2008)

und wie versprochen noch nachgereicht :

Ich habe nun (gezwungenermaßen) Versuche mit meinen beiden Auswertungs-Bausteinen gemacht. Dabei kam folgendes heraus :

CPU 317

DFT-Analyse - 256 Werte aufgezeichnet - Zeitbedarf Auswertung : 2,3 s
DFT-Analyse - 512 Werte aufgezeichnet - Zeitbedarf Auswertung : > 5 s

FFT-Analyse - 256 Werte aufgezeichnet - Zeitbedarf Auswertung : 0,12 s
FFT-Analyse - 512 Werte aufgezeichnet - Zeitbedarf Auswertung : 0,25 s
FFT-Analyse 1024 Werte aufgezeichnet - Zeitbedarf Auswertung : 0,51 s

somit macht die FFT-Analyse für mich das Rennen. Mit der DFT-Analyse ist der Code zwar kompakter und es wäre eigentlich mein Favourit gewesen, aber die Dauer ist hier das entscheidende.

Fall sich also für den einen oder anderen dieses Problem stellt, so sei hier gesagt, dass es mit hinreichender Genauigkeit möglich ist, mittels der SPS diese Auswertung durchzuführen.

Ich möchte auf diesem Weg nochmals allen meinen Dank sagen, die mir hier "aufs Pferd geholfen haben".

Gruß
LL


----------



## Larry Laffer (10 Januar 2008)

weiterer Nachtrag :
Ich habe die Abfrage-Rate der Messung auf 3 ms festgelegt. Damit lassen sich mit gute Wiederholgenauigkeit Einzel-Frequenzen bis 120 Hz sicher feststellen und im Pegel nachweisen.
Zur Messung verwende ich aktuell einen Piezo-Schwingungssensor.


----------



## Longbow (10 Januar 2008)

IBN-Service schrieb:


> Hallo LL,
> 
> 200 Messungen pro Sekunden erfordern aber nicht nur ne leistungsfähige
> SPS sondern auch recht schnelle Analogeingänge...
> ...



Sorry, ist jetzt etwas aus der Vergangenheit des Threads herausgeholt:
Für das "schneller Analog Eingang"-Problem gibt es im S7 Bereich eine Lösung:

bis zu 8 Kanäle Abtasten alle 25µs (40kHz) mit Zwischenspeicherung im Modul und Abholen nach Bedarf (reicht z.B. alle 4 ms)!
Auch mit Triggerfunktion einsetzbar.


----------



## Larry Laffer (10 Januar 2008)

... erzähl ...
was nimmst du dafür ?


----------



## Longbow (10 Januar 2008)

Larry Laffer schrieb:


> ... erzähl ...
> was nimmst du dafür ?



Ich wollte jetzt nicht Werbung machen deswegen erst jetzt:

VIPA
CPU mit normalen I/Os und mehr Rechenleistung als 317
314-6CF02   CPU 314ST/DPM - SPEED7-Technologie

Schnelle Eingänge mit Speicherfunktion
331-7BF70   SM 331S - Analoge Eingabe FAST - SPEED-Bus

Speedbus Backplane zur linken Seite (an der rechten Seite gehen die normalen Module)
391-1AF10	BP 391 SPEED-Bus, DIN rail, 530mm, 2xEs


Bei Bedarf ist es mit dem System auch möglich von der CPU aus mit dem OB28
alle 250µs Werte aus dem Analogmodul zu holen. (OB28 ist wie OB35 nur fest
auf 250µs, OB29 ist fest auf 500µs)


----------



## drfunfrock (10 Januar 2008)

Ich würde den Aliasfilter nicht vergessen, sonst erhält man Messungen, die nicht korrekt sind. Daher der Aliasfilter sollte Frequenzen oberhalb der halben Abtastfrequenz unterdrücken und zwar so viel, dass das LSB des AD-Konverters auf diese Frquenzen nicht mehr anspricht. Da kein Filter derart exakt ist, wird man nicht das volle Spektrum bis Fabtast/2 nutzen können. Der Aliasfilter sollte idealerweise im AD-Konverter liegen. 

Der Hintergrund ist der, dass bei der Abtasttung bei Fabtast/2 die Frequenzen gespiegelt werden, so dass es zu Überlagerungen kommt. Der Filter ist häufig ein Problem, wenn der steil sein muss, weswegen man gerne Fabtast erhöht, um die Filterkurve flacher machen zu können, was auch wesentlich billiger ist. 


Etwas was zu berücksichtigen sein könnte, ist die Samplezeit. Während die Eingangsspannung eingelesen wird, ändert sich der Eingang. Dieses Samplefenster wirkt sich derart aus, dass je breiter dieses Fenster ist, desto ungenauer die Frequenzbestimmung.Beckhoff 12-Bit-Ethercat-Klemmen haben eine Wandlungszeit von 500us. Über die Samplezeit wird natürlich nichts geschrieben und ich muss davon ausgehen, dass der AD-Wandler ohne Sample-und-Hold-Glied am Eingang liegt. 

Ein billiges Oszilloskop von Agilent, macht das übrigens auch und mit allem was man benötigt. Man kann das dann sogar per RS232 machen. Der Eingangswiderstand ist dann 1Megaohm und weitere Funktionen, um die Hauptfrequenzen herauszubekommen sind kein Problem. Ich würde das der SPS vorziehen.


----------



## Larry Laffer (10 Januar 2008)

@Longbow:
Ich werde das mal im Hinterkopf behalten. Im Augenblick ist der Umstieg kein Thema ...

@drfunfrock:
Samplingrate im Moment : jede ms.
OB35-Aufruf alle 3 ms - sicher ist auch alle 2 ms machbar, bringt aber keinen entscheidenen Zugewinn. Mit Filtern habe ich bei / mit einem Konkurenzprodukt (Delphin) gearbeitet. Hier spielte es keine Rolle, ob der relativ komplizierte Filter von denen aktiv war oder nicht. Somit arbeitet mein Auswerte-Programm derzeit (natürlich) auch ohne. Zur Zeit keine Nachteile erkennbar. Der festgestellten Frequenz-Ereignisse bewegen sich sehr exakt im Bereich der erwarteten Symptom-Frequenzen. Bei meinen Lagern mit der aktuellen Drehzahl zur Zeit 64 Hz und 40 Hz.

Gruß
LL


----------



## drfunfrock (10 Januar 2008)

Habe meinen Beitrag noch einmal ein Update verpasst.


----------



## drfunfrock (10 Januar 2008)

Larry Laffer schrieb:


> @Longbow:
> Ich werde das mal im Hinterkopf behalten. Im Augenblick ist der Umstieg kein Thema ...
> 
> Samplingrate im Moment : jede ms.
> ...


Du hast eine Abtastfrq. von 1000Hz. Der Filter müsste also bei 500Hz liegen. Damit sollte ein Filter 2. oder 4. Ordnung ausreichen, was sich mit OPs machen lässt.  Es kann aber sein, dass in deinen Konvertern schon einer drin ist. Ich würde mir die Arbeit nicht machen und lieber einen Oscar spendieren. Das Problem ist, dass du nicht weisst, wann die Aliasfrequenzen dich stören und du musst sie filtern.


----------



## Ralle (10 Januar 2008)

Larry Laffer schrieb:


> @Longbow:
> Ich werde das mal im Hinterkopf behalten. Im Augenblick ist der Umstieg kein Thema ...
> 
> @drfunfrock:
> ...



Und was für eine Analogkarte setzt du ein, wie schnell ist die? Ich hatte das auch mal getestet, da kannst du so schnell abfragen wie du möchtest, die Werte ändern sich dann ebend nur jedes 3. oder 4. Mal. Ist also auf jeden Fall mal interessant, die Datenreihe genauer anzusehen, um festzustellen, was der AD-Wandler wirklich bringt.


----------



## Larry Laffer (10 Januar 2008)

@Ralle:
Da ich jetzt nicht mehr auf der Arbeit bin und nicht genau nachschauen kann schiesse ich mal aus der Hüfte. Ich behaupte mal die Karte heißt : 335-7HG01
In den Parametern läßt sie sich auf eine Abtastrate von 1ms einstellen. Ich erhalte beim Einlesen über den OB35 auch keine 2 gleichen Werte beim Einlesen. Ich muss aber gestehen, dass diese Abtast-Frequenz das absolute Max. meiner bisherigen Mess- und Auswerte-Versuche darstellt.

@drfunfrock:
Die Idee mit dem externen Gerät (in diesem Fall wie schon ein paar mal erwähnt von Fa. Delphin) war der Start dieser Geschichte von Seiten meiner Firma. Dieses Gerät macht angeblich 20.000 Messungen in 3,2 Sek. und hat alles an Filtern, was man sich vorstellen kann. Dummerweise (und da kommt dann mein Neben-Projekt ins Spiel) liefert es KEINE reproduzierbaren Ergebnisse ein und desselben Lagers. Die Amplitudenwerte an den Symptom-Frequenzen streuen zischen 5 und 15 - oder anders gesagt zwischen IO und NIO. Wie soll man so eine Auswertung fahren ?
Meine Eigene kleine Bastelei, eigentlich als Add-On zu einer bestehenden Anordnung gedacht, obwohl von den Fähigkeiten wesentlich primitiver, macht diese Streuung nicht. Ein Lager schwankt an der Symptom-Frequenz und aber auch im Rest-Spektrum nur um +/- 5% zwischen 2 Messungen (maximal) - und ich habe wirklich viel getestet heute.
Was würdest daraus nun für Schlüsse ziehen ?

Gruß
LL

Nachtrag:
Ich möchte hier niemanden meine Arbeit verkaufen. Ich habe nur ein paar Leuten im Forum, die mich bei dieser Sache auf die richtige Spur gebracht haben, versprochen, über den Fortgang dieser Geschichte zu berichten, was ich nun hiermit getan habe. Vielleicht hilft es ja irgendwann irgendwem weiter ...


----------



## drfunfrock (11 Januar 2008)

Das die Frequenz schwankt ist nicht ungewöhnlich. Das du andere Ergebisse mit der externen Box erhälst, kann schon daran liegen, dass das Sample- und Hold-Glied am Eingang des AD-Wandlers  eine andere Zeitspanne zum Sampeln benötigt. Je kleiner diese Zeitspanne, desto genauer kannst du verschiedene Frequenzen von einander unterscheiden. Daher auch dein Problem mit den schwankenden Frequenzen. Das externe Gerät arbeitet einfach genauer, während dein SPS-Eigenbau 2 nebeneinanderliegende Linien zu einer macht, weil ich vermute, dass die Samplefrequenz gleich der Wandlungszeit ist. 

Der Punkt ist der, dass die Gleichungen für die FFT in der Regel für die Abtastung mit  einem unendlich schmalen Dirac-Impuls angegeben werden. Das ist natürlich nicht die Realität. Die Abtastung sieht so aus, dass man z.B. über eine Zeit deltaT die Spannung am Eingang einliesst. Somit gleicht die Abtastfunktion mehr einem Rechteck. Dh. wird das Eingangssignal noch mit dieser Rechtecksfunktion verknüpft. Das Resultat ist das, je grösser deltaT wird, desto schlechter die Unterscheidung zwischen nebeneinanderliegenden Frequenzlinien. Dh. in deinem Fall wirst du eine Art Mittel erhalten, was anscheinend genügend ist.


----------



## Larry Laffer (11 Januar 2008)

@drfunfrock:
Fast keinen Einwand zu deinem Beitrag ...
Frequenz-Schankungen wären OK und liegen sicher auch in der Natur der Sache. Amplituden-Schwankungen in dem geschilderten Maße m.E. nicht. Zur Verdeutlichung :
Ein Amplituden-Ausschlag von 5 wäre gerade noch IO. Darüber eigentlich NIO. Schwankungen in der Abtastung von 5 - 15 in einem Frequenzband bei Mittelung der Werte bei dem gleichen Teil für das Prüfverfahren nicht tolerierbar. 
Mir ist klar, dass meine Auswertung möglicherweise von seiner "Ungenauigkeit" profitiert. So etwas ähnliches hatte ich an anderer Stelle auch schon mal. Entscheidend ist aber in der Hauptsache, dass die Auswerte-Ergebnisse reproduzierbar sind und das kann "mein" FFT-FB interessanterweise leisten.
Ich habe aber (angeregt durch deine Beiträge) noch ein paar Manipulationen im Hinterkopf, die ich auf jeden Fall noch testen werde / möchte. Mal sehen, was dabei herauskommt. Ich werde davon berichten ...

Gruß
LL


----------



## fsxela (10 Januar 2014)

Hallo Larry, kannst du mir den Code für die FFT-Analyse zu kommen lassen? 
Gruß
Alex


----------



## Larry Laffer (11 Januar 2014)

Hallo Alex,

ich beantworte das mal hier (auf die PN bekommst du also nicht noch zusätzlich ein Feedback )

Selbstverständlich kann ich dir den Code zukommen lassen (ihn hier veröffentlichen). Das werde ich nächste Woche dann machen.
Du mußt allerdings schon die schon angesprochenen Einschränkungen in Kauf nehmen :
- die Zykluszeit der Auswertung wächst exponentiell zur Anzahl der auszuwertenden Messwerte.
- aufgrund der Abtastrate bis bu hinsichtlich der Frequenzen, die sinnvoll abgebildet werden, eingeschränkt.

Verrätst du mir im Gegenzug, was du damit vor hast ?

Gruß
Larry


----------



## fsxela (11 Januar 2014)

Hallo Larry, 
die Schwingungsanalyse ist für einen Getriebeprüfstand gedacht. Ein Schwingungssensor (ein PCH1272 4..20mA) wird am Analogeingang eines  SM_1231 AI4_13Bit  eingelesen und mit der SPS S7_1212C ausgewertet.
Das zu erwartende Frequenzspektrum liegt im Bereich 10...400Hz, wobei ich mit der Hardware nur die Schwingungen bis ca. 200Hz einlesen und analysieren kann (die Schwingungen an der Welle 1 des Getriebes n = 1460 1/min werden leider nicht zu analysieren sein).
Ich habe das Ganze schon mit DFT umgesetzt (N = 500, OB30 = 2ms, FK=250 => Ausgabe-Frequenzspektrum = bis 250Hz), aber die Auswertungszeiten liegen "jenseits von Gut und Böse"..... 
Ich muss ehrlich gestehen, dass ich den FFT Algorithmus nicht ganz nachvollziehen kann (DFT ist dagegen um einiges verständlicher), aber ist es nicht so, dass die Zykluszeit mit DFT um N² und mit FFT um N*log(N) ansteigt?

Gruß
Alex


----------



## fsxela (11 Januar 2014)

Hallo Larry,

du hast bestimmt mit:  "- die Zykluszeit der Auswertung wächst exponentiell zur Anzahl der auszuwertenden Messwerte " das gedacht, dass N*log(N) = N*10^(exp.),
da log(N)= exp.?
Der FFT-Algorithmus ist um einiges schneller als der DFT-Algorithmus.


Gruß
Alex


----------



## Larry Laffer (11 Januar 2014)

Du hast Recht, dass der FFT sehr viel schneller ist als der DFT - trotzdem vergeht einiges an Zeit bei der Auswertung.
Ob du da mit deiner 1212 glücklich wirst möchste ich ein wenig bezweifeln.
Ich bin mir wegen der genauen Zeiten nicht mehr so ganz sicher - habe es aber so in Erinnerung : CPU 317 , Aufzeichnungs-Intervall 1ms für eine Sekunde = 1000 Werte := Auswertezeit deutlich über 1 Sekunde. Ich meine, dass es so war (das geht auch glaube ich aus der Formel mit der darin stattfindenden Iteration hervor), dass die Verdoppelung der Werte eine Vervierfachung der Auswertezeit bedingt hat.

Bei uns hatte der Algorhythmus letztlich nicht den erwarteteten Ausschlag gebracht sondern ein sehr viel einfacheres Verfahren : ich habe keine Schwingung mehr aufgezeichnet sondern das Reibmoment (wobei darin ja letztlich auch eine Schwingung abgebildet wird) mit einer schneller Messrate. Diese Kurve habe ich dann leicht geglättet und die geglättete Version von der Rohversion subtrahiert und die Ergebnis-Werte absolut dargestellt. Es ging uns letztlich auch gar nicht um eine spezielle Frequenz sondern nur um Geräusche allgemein. Die so erzeugte "neue" Kurve stellte nun den Geräusch-Anteil des Lagers recht gut dar.

Gruß
Larry


----------



## fsxela (11 Januar 2014)

Auf dem Prüfstand werden die Getrieben auf der Lebensdauer getestet und die evt. Schwachstellen, mittels der Zuordnung mit der Zeit steigenden Amplituden der Schwingungen zu den Lagern und Zahnräder, ermittelt.
Die Belastungsroutine für das Getriebe läuft auf einer separaten SPS (auch eine 1212C), die Schwingungsanalyse übernimmt eine SPS die nur die FFT macht.

Mit der DFT-Auswertung von N=500 (die Aufnahmezeit = 1 sec) ist die SPS über 7 sec beschäftigt - das ist sehr, sehr lang. Deswegen möchte ich den FFT-Algorithmus einsetzen und hoffe damit auf die Auswertungszeit von ca. 200-300ms zu kommen. 

PS. - Larry, was für die Hardware hast du für die Reibmomentaufnahme gehabt?

Gruß
Alex


----------



## Larry Laffer (14 Januar 2014)

Hallo,

so ... nun komme ich dazu, mich wieder mit dieser Angelegenheit zu befassen.

Bei der Reibmomentmessung habe ich mit einem passenden DM-Sensor und einer schnellen Analogkarte gearbeitet. Hier sind auch (zumindestens bei einer S7-300 500 bis 1000 Messung in der Sekunde machbar)

Nun zu deinem Code-Wunsch :

```
FUNCTION_BLOCK FB168                                    // UP Mess-Daten aufzeichnen und FFT-Analyse
TITLE   = 'UP Mess-Daten aufzeichnen und FFT-Analyse'   // UP Mess-Daten aufzeichnen und FFT-Analyse
AUTHOR  : 'Larry'
VERSION : '1.6'   //   20.04.2009
FAMILY  : 'LL_Std'
KNOW_HOW_PROTECT
CONST  
    Array_max   := 2048 ;           // max. Anzahl von Einträgen im Array
    
    Pi          := 3.1415926 ;
    Tag_in_ms   := 86400000 ;
END_CONST
VAR_INPUT
   akt_Messwert           : INT ;   // akt. Messwert (INT)
   Anzahl_Werte           : INT ;   // Anzahl der zu erfassenden Werte [max. = 1024]
   Drehzahl_Messung       : REAL ;  // Drehzahl während der Messung  (1/Min.)
   
   Werte_doppeln          : BOOL ;  // ? Daten verdoppeln / Zwischen-Daten bilden
   Auswertung_x2          : BOOL ;  // ? Auswertung quadrieren
   Auswertung_glaetten_1  : BOOL ;  // ? vor der Auswertung glätten
   Auswertung_glaetten_2  : BOOL ;  // ? nach der Auswertung glätten
   
   akt_Uhrzeit            : TOD ;   // aktuelle Uhrzeit
   akt_Datum              : DATE ;  // aktuelles Datum
   Faktor_Amplitude : REAL := 1.0 ; // Anpassung der Ampituden-Darstellung
   
   _Steuerung             : INT ;   // Steuer-Eingänge :
   CMD_Reset_Puffer       : BOOL ;  // -Reset der Daten-Aufzeichnung
   CMD_Einlesen           : BOOL ;  // -Daten einlesen
   CMD_Auswertung         : BOOL ;  // -Daten auswerten
END_VAR
VAR_IN_OUT
   _Meldungen             : INT ;   // Melde-Ausgänge :
   OK_Reset_Puffer        : BOOL ;  // -Reset der Daten-Aufzeichnung erfolgt
   Messung_aktiv          : BOOL ;  // -Messung ist gestartet
   Liste_voll             : BOOL ;  // -alle/vorgegebene Daten sind erfasst
   OK_Auswertung          : BOOL ;  // -Daten sind ausgewertet
   Auswertung_IO          : BOOL ;  // -Auswertung ist IO
   Auswertung_NIO         : BOOL ;  // -Auswertung ist NIO
END_VAR
VAR_OUTPUT
END_VAR
 

VAR
   Last_Messwert          : INT ;        // Wert des zuletzt eingelesenen Messwertes
   Index                  : INT ;        // Zeiger auf Daten-Index für "Daten Einlesen"
   
   FB_noch_aktiv          : BOOL := false ;   // Baustein wird noch bearbeitet
   Daten_Init_OK          : BOOL := false ;   // Datenbereich ist initialisiert
   Daten_Liste_voll       : BOOL := false ;   // Ende des Datenbereichs beim Schreiben erreicht
   Messung_gestartet      : BOOL := false ;   // HM "Messung ist gestartet"
   Messung_beendet        : BOOL := false ;   // HM "Ende der Messung"
   FM_Messung_beendet     : BOOL := false ;   // Flankenmerker "Ende der Messung"
   VorgabeWerte           : ARRAY [1..5] OF STRUCT 
      Aktiv               : BOOL ;   // Messbereich auswerten ?
      F_min               : REAL ;     // unterste Auswerte-Frequenz
      F_max               : REAL ;     // oberste  Auswerte-Frequenz
      MittelWert          : REAL ;     // max. Mittelwert der Messerte im vorgegebenen Bereich 
      MaxWert             : REAL ;     // max. Spitzenwert der Messerte im vorgegebenen Bereich 
   END_STRUCT ;  

   Auswertung : STRUCT 
      Anzahl_Werte           : INT ;    // Anzahl der Quell-Werte
      Frequenz_Faktor        : REAL ;   // Teilungs-Faktor Frequenz in der Auswertung  [Hz/Index]
      Anzahl_MessWerte       : INT ;    // Anzahl der Mess-Werte
      
      Datum                  : DATE ;   // Datum beim Start der Messung
      Uhrzeit_Start          : TOD ;    // Uhrzeit beim Start der Messung
      Uhrzeit_Ende           : TOD ;    // Uhrzeit beim Ende der Messung
      Dauer_der_Messung      : REAL ;   // Dauer der letzten Messung [s]
      Anz_Umdrehungen        : REAL ;   // Anzahl der Umdrehungen während der Messung 
      
      max_Amplitude          : REAL ;   // größter Amplituden-Wert
      Mittelwert             : REAL ;   // Mittelwert aller Messwerte
      Freq_Schwerpunkt       : INT ;    // Werte-Schwerpunkt bei Frequenz
      
      MessBereich            : ARRAY[1..5] OF STRUCT
         MittelWert          : REAL ;   // Mittelwert der Messerte im vorgegebenen Bereich 
         MaxWert             : REAL ;   // Maximalwert der Messerte im vorgegebenen Bereich 
         Mittelwert_NIO      : BOOL ;   // Mittelwert > Vorgabewert
         Maxwert_NIO         : BOOL ;   // Maximalwert > Vorgabewert
      END_STRUCT ;  
      
      Amplitude              : ARRAY [0..Array_max/2] OF INT ; // Frequenz-Spektrum  //  Index * "Frequenz_Faktor" ergibt die Frequenz des Datenpunktes
   
      Werte_real             : ARRAY [0..Array_max] OF REAL ;  // Quell-Werte Real-Teil
      Werte_imag             : ARRAY [0..Array_max] OF REAL ;  // Quell-Werte Imaginär-Teil
   END_STRUCT ;  
END_VAR

VAR_TEMP
   i , j , k , L  : INT ;    // Schleifen-Variable
   X , Y          : INT ;
 
   Anz_Bits       : INT ;       
   Bit_Maske      : INT ;       
   Winkel         : REAL ;
   Frequenz       : REAL ;
   temp , temp2   : REAL ;
   Bereich_Summe  : ARRAY [0..7] OF REAL ;
   Bereich_Werte  : ARRAY [1..5] OF INT ;
   wCos , wSin    : REAL ;
   tReal , tImag  : REAL ;
   
   h_Uhrzeit      : DINT ;  // HM Zeit-Messung 
   
   Glaettung, k1, k2 : INT ;
   Glaettung_Teiler  : INT ;
   Glaettung_Summe   : REAL ;
END_VAR
// -----------------------------------------------------------------------------------------------------------------------
BEGIN
// -----------------------------------------------------------------------------------------------------------------------
IF NOT FB_noch_aktiv THEN
   FB_noch_aktiv := true ;
```


----------



## Larry Laffer (14 Januar 2014)

Teil 2 :

```
// -----------------------------------------------------------------------------------------------------------------------
// --- Daten-Baustein initialisieren -------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------------------
IF CMD_Reset_Puffer AND NOT OK_Reset_Puffer THEN
   FOR i := 0 TO Array_max/2 BY 1 DO
      Auswertung.Amplitude [i]  := 0 ;
   END_FOR ;
   FOR i := 0 TO Array_max BY 1 DO
      Auswertung.Werte_real [i] := 0.0 ;
      Auswertung.Werte_imag [i] := 0.0 ;
   END_FOR ;
   Auswertung.Anzahl_Werte     := 0 ;
   Auswertung.Anzahl_MessWerte := 0 ;
   Auswertung.Frequenz_Faktor  := 0.5 ;
   
   Auswertung.max_Amplitude    := 0.0 ;
   Auswertung.Mittelwert       := 0.0 ;
   Auswertung.Freq_Schwerpunkt := 0 ;
   Auswertung.Datum   := D#1990-01-01 ;
   Auswertung.Uhrzeit_Start := TOD#0:0:0.0 ;
   Auswertung.Uhrzeit_Ende  := TOD#0:0:0.0 ;
   
   FOR j := 1 TO 5 BY 1 DO 
      Auswertung.MessBereich[j].MittelWert     := 0.0 ;    // Mittelwert der Messwerte im vorgegebenen Bereich 
      Auswertung.MessBereich[j].MaxWert        := 0.0 ;    // Maximalwert der Messwerte im vorgegebenen Bereich 
      Auswertung.MessBereich[j].Mittelwert_NIO := false ;  // Mittelwert > Vorgabewert
      Auswertung.MessBereich[j].Maxwert_NIO    := false ;  // Maximalwert > Vorgabewert
   END_FOR ;
   
   Daten_Liste_voll := false ; 
   Index := 0 ;
   Last_Messwert := 0 ;
   
   CMD_Einlesen    := False ;
   CMD_Auswertung  := False ;
    OK_Auswertung  := False ;
   Auswertung_IO   := False ;
   Auswertung_NIO  := False ;
    
   Messung_gestartet := false ;
   FM_Messung_beendet := false ;
    
   Daten_Init_OK := true ; 
END_IF ;
OK_Reset_Puffer := CMD_Reset_Puffer ;
// -----------------------------------------------------------------------------------------------------------------------
// --- Daten der Messung einlesen ----------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------------------
IF CMD_Einlesen
   AND Daten_Init_OK
   AND NOT CMD_Reset_Puffer
   AND NOT CMD_Auswertung
   AND NOT Daten_Liste_voll
   THEN
    
   IF NOT Werte_doppeln THEN  // Werte im Takt des OB-Aufruf's einlesen
      Auswertung.Werte_real [Index] := INT_TO_REAL (akt_Messwert) ;
      Index := Index + 1 ;
   ELSE                       // Zwischenwerte bilden zwischen akt. Wert und letztem Wert
      Auswertung.Werte_real [Index] := INT_TO_REAL (akt_Messwert + Last_Messwert) / 2.0 ;
      Index := Index + 1 ;
      IF Index <= Array_max then
         Auswertung.Werte_real [Index] := INT_TO_REAL (akt_Messwert) ;
         Index := Index + 1 ;
      END_IF ;   
      Last_Messwert := akt_Messwert ;
   END_IF ;
  
   IF NOT Messung_gestartet THEN
      Auswertung.Datum   := akt_Datum ;
      Auswertung.Uhrzeit_Start := akt_Uhrzeit ;
      Auswertung.Uhrzeit_Ende  := TOD#0:0:0.0 ;
      Auswertung.Anzahl_Werte  := Anzahl_Werte ;
      Messung_gestartet := true ;
   END_IF ; 
END_IF ;
Messung_aktiv := Messung_gestartet ;
// -----------------------------------------------------------------------------------------------------------------------
Daten_Liste_voll := (Index > Anzahl_Werte) OR (Index > Array_max) ;
Liste_voll := Daten_Liste_voll ;
Messung_beendet := Daten_Liste_voll ; // or (Messung_gestartet AND NOT CMD_Einlesen) ;
IF Messung_beendet AND NOT FM_Messung_beendet THEN
   Auswertung.Uhrzeit_Ende := akt_Uhrzeit ; ;
   h_Uhrzeit := TOD_TO_DINT(Auswertung.Uhrzeit_Ende) - TOD_TO_DINT(Auswertung.Uhrzeit_Start) ; 
      IF h_Uhrzeit < 0 THEN h_Uhrzeit := h_Uhrzeit + Tag_in_ms ; END_IF ;
   Auswertung.Dauer_der_Messung := DINT_TO_REAL (h_Uhrzeit) / 1000.0 ;
   Auswertung.Anzahl_Messwerte := Index -1 ;
   FM_Messung_beendet := true ;
END_IF ;    


// -----------------------------------------------------------------------------------------------------------------------
// --- Daten der Messung auswerten ---------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------------------
IF CMD_Auswertung AND NOT OK_Auswertung 
AND NOT CMD_Einlesen 
   THEN
    
// vor der Analyse die Werte-Tabelle glätten
   IF Auswertung_glaetten_1 THEN 
      FOR i := 1 TO Auswertung.Anzahl_Messwerte -1 BY 1 DO
         temp := Auswertung.Werte_real [i] + Auswertung.Werte_real [i+1] ;
         Auswertung.Werte_real [i] := temp / 2.0 ;
      END_FOR ;
      temp := Auswertung.Werte_real [Auswertung.Anzahl_Messwerte] + Auswertung.Werte_real [1] ;
      Auswertung.Werte_real [Auswertung.Anzahl_Messwerte] := temp / 2.0 ;
   END_IF ;
   
   
// FFT-Analyse
   FOR i := 1 TO Auswertung.Anzahl_Messwerte BY 1 DO          // beim Start sind Real- und Imaginär-Anteil zunächst gleich ...
      Auswertung.Werte_imag [i] := Auswertung.Werte_real [i] ;
   END_FOR ;
   
   Anz_Bits := REAL_TO_INT (LOG(Auswertung.Anzahl_Werte) / LOG(2.0)) ;  
   
   FOR j := 1 TO Anz_Bits BY 1 DO 
      Bit_Maske := WORD_TO_INT (SHL (IN:=w#16#1 , N:=j)) ;    // entspricht: 2^j
      L := Auswertung.Anzahl_Werte / Bit_Maske ;              // L := Auswertung.Anzahl_Werte / (2 ^ j) ;
      Winkel := Pi / L ;
      FOR k := 0 TO Auswertung.Anzahl_Werte - 1 BY 2 * L DO 
         FOR i := 0 TO L - 1 BY 1 DO 
            wCos := COS(i * Winkel) ; 
            wSin := SIN(i * Winkel) ;
            X := (k + i) ;
            Y := (k + i + L) ;
            IF (X <= Array_max) AND (Y <= Array_max) THEN
               Auswertung.Werte_real [X] := Auswertung.Werte_real [X] + Auswertung.Werte_real [Y] ;
               Auswertung.Werte_imag [X] := Auswertung.Werte_imag [X] + Auswertung.Werte_imag [Y] ;
               tReal := Auswertung.Werte_real [X] - 2 * Auswertung.Werte_real [Y]  ;
               tImag := Auswertung.Werte_imag [X] - 2 * Auswertung.Werte_imag [Y]  ;
               Auswertung.Werte_real [Y] := tImag * wSin + tReal * wCos ;
               Auswertung.Werte_imag [Y] := tImag * wCos - tReal * wSin ;
            END_IF ;   
         END_FOR ;
      END_FOR ;
   END_FOR ;

   // Bits invertieren - Werte umgruppieren
   j := 0 ;
   FOR i := 0 TO Auswertung.Anzahl_Werte - 2 BY 1 DO 
      IF i < j THEN  // austauschen (i) gegen (j)
         temp := Auswertung.Werte_real [j] ;
         Auswertung.Werte_real [j] := Auswertung.Werte_real [i] ;
         Auswertung.Werte_real [i] := temp ;
      
         temp := Auswertung.Werte_imag [j] ;
         Auswertung.Werte_imag [j] := Auswertung.Werte_imag [i] ;
         Auswertung.Werte_imag [i] := temp ;
      END_IF ;
      k := Auswertung.Anzahl_Werte / 2 ;
      
      WHILE k < (j + 1) DO
         j := j - k ;
         k := k / 2 ;
      END_WHILE ;
      j := j + k ;
   END_FOR ;
```


----------



## Larry Laffer (14 Januar 2014)

Teil 3 :


```
// errechnete Werte nach-berechnen
   Auswertung.Anzahl_MessWerte := Auswertung.Anzahl_Werte / 2 ;
//   Auswertung.Frequenz_Faktor := 1.0 / Auswertung.Dauer_der_Messung ;
   Auswertung.Frequenz_Faktor := 500.0 / Auswertung.Anzahl_Werte ;
   Auswertung.Anz_Umdrehungen := Drehzahl_Messung * Auswertung.Dauer_der_Messung / 60.0 ;
   FOR i := 0 TO Auswertung.Anzahl_MessWerte -1 BY 1 DO 
      tReal := Auswertung.Werte_real [i] ;   IF tReal < 0 THEN tReal := -tReal ; END_IF ;  // negative Werte invertieren ...
      tImag := Auswertung.Werte_imag [i] ;   IF tImag < 0 THEN tImag := -tImag ; END_IF ;
      temp := (tReal + tImag) / INT_TO_REAL (Auswertung.Anzahl_Werte) ;   // Amplitude des Ausgabe-Wertes
      temp2 := temp * Faktor_Amplitude / Auswertung.Anz_Umdrehungen ;
      
      IF Auswertung_x2 THEN   // Ausgabe quadrieren ?
         temp2 := temp2 * temp2 / 50.0 ;
      END_IF ;   
      
      Auswertung.Werte_real [i] := temp2 ;
   END_FOR ;
   Auswertung.Werte_real [Auswertung.Anzahl_MessWerte] := 0.0 ;
   
   
// nach dem Überprüfen die Werte-Tabelle glätten
   IF Auswertung_glaetten_2 THEN 
      Glaettung := 8 ;
      FOR i := 0 TO Auswertung.Anzahl_Messwerte -1 BY 1 DO
         Glaettung_Summe := 0.0 ; Glaettung_Teiler := 0 ;
         k1 := i - (Glaettung / 2) ;  
         k2 := k1 + Glaettung ; 
            IF k1 < 1 THEN k1 := 1 ; END_IF ;
            IF k2 > Auswertung.Anzahl_Messwerte THEN k2 := Auswertung.Anzahl_Messwerte ; END_IF ;
         FOR j := k1 TO k2 BY 1 DO
            Glaettung_Summe := Glaettung_Summe + Auswertung.Werte_real [j] ;
            Glaettung_Teiler := Glaettung_Teiler + 1 ;
         END_FOR ;   
         Auswertung.Werte_real [i] := Glaettung_Summe / INT_TO_REAL (Glaettung_Teiler) ;
      END_FOR ;
   END_IF ;
   
   
   // errechnete Werte ausgeben und überprüfen
   Bereich_Summe [0] := 0.0 ;    // Auswertung.Mittelwert
   FOR j := 1 TO 5 BY 1 DO 
      Bereich_Werte [j] := 0 ;      // Anzahl Werte im Bereich
      Bereich_Summe [j] := 0.0 ;    //  Summe Werte im Bereich
   END_FOR ;    
     
   FOR i := 0 TO Auswertung.Anzahl_MessWerte -1 BY 1 DO 
      temp := Auswertung.Werte_real [i] ; IF temp < 0.01 THEN temp := 0.01 ; END_IF ;
      
      Bereich_Summe [0] := Bereich_Summe [0] + temp ;
      Frequenz := INT_TO_REAL (i+1) * Auswertung.Frequenz_Faktor ;
      
      FOR j := 1 TO 5 BY 1 DO 
         IF VorgabeWerte[j].Aktiv AND 
            (Frequenz >= VorgabeWerte[j].F_min) AND (Frequenz <= VorgabeWerte[j].F_max) THEN 
                Bereich_Summe [j] := Bereich_Summe [j] + temp ; 
                Bereich_Werte [j] := Bereich_Werte [j] + 1 ; 
                IF temp > Auswertung.MessBereich[j].MaxWert THEN Auswertung.MessBereich[j].MaxWert := temp ; END_IF ;
         END_IF ;
      END_FOR ;  
      
      IF (temp > Auswertung.max_Amplitude) THEN Auswertung.max_Amplitude := temp ; END_IF ;
      Auswertung.Amplitude [i] := REAL_TO_INT (temp * 10.0) ; 
   END_FOR ;
   Auswertung.Mittelwert := Bereich_Summe [0] / INT_TO_REAL (Auswertung.Anzahl_MessWerte) ;  // Mittelwert der Kurven-Werte
   // Schwerpunkt des Wertebereichs berechnen
   Bereich_Summe[6] := Bereich_Summe[0] / 2.0 ;
   Bereich_Summe[7] := 0.0 ;   
   FOR i := 0 TO Auswertung.Anzahl_MessWerte -1 BY 1 DO 
      temp := Auswertung.Werte_real [i] ; IF temp < 0.01 THEN temp := 0.01 ; END_IF ;
      Bereich_Summe[7] := Bereich_Summe[7] + temp ;
      IF Bereich_Summe[7] >= Bereich_Summe[6] THEN 
         Auswertung.Freq_Schwerpunkt := REAL_TO_INT(INT_TO_REAL (i+1) * Auswertung.Frequenz_Faktor) ;
         EXIT ;
      END_IF ;   
   END_FOR ;

  
   // Auswertung IO / NIO   
   Auswertung_NIO := false ;
   FOR j := 1 TO 5 BY 1 DO 
      IF VorgabeWerte[j].Aktiv THEN 
         Auswertung.MessBereich[j].MittelWert := Bereich_Summe [j] / INT_TO_REAL (Bereich_Werte [j]) ;       // Mittelwert
         Auswertung.MessBereich[j].Mittelwert_NIO := (Auswertung.MessBereich[j].MittelWert > VorgabeWerte[j].MittelWert) ;
         Auswertung.MessBereich[j].Maxwert_NIO    := (Auswertung.MessBereich[j].MaxWert > VorgabeWerte[j].MaxWert) ;
      END_IF ; 
      Auswertung_NIO := Auswertung_NIO OR Auswertung.MessBereich[j].Mittelwert_NIO OR Auswertung.MessBereich[j].Maxwert_NIO ;
   END_FOR ;
   Auswertung_IO := NOT Auswertung_NIO ;
      
   OK_Auswertung := true ;
END_IF ;
// ----------------------------------------------------------------------------------------------------------------------
   FB_noch_aktiv := false ;
END_IF ;  // FB_noch_aktiv
IF FB_noch_aktiv THEN
IF NOT CMD_Reset_Puffer AND NOT CMD_Einlesen AND NOT CMD_Auswertung THEN 
   FB_noch_aktiv := false ;
END_IF ; END_IF ;  
// -----------------------------------------------------------------------------------------------------------------------
END_FUNCTION_BLOCK
// -----------------------------------------------------------------------------------------------------------------------
```


----------



## fsxela (16 Januar 2014)

Hallo Larry, 
danke für den Code.
Habe heute ein Teil davon (FFT-Analyse) übernommen, aber leider keine saubere Darstellung im FFT-Diagramm  bekommen. Die Amplitude erscheint nicht an den richtigen Frequenzen und die Größe passt nicht.
Ich glaube mein Fehler befindet sich im Segment "// errechnete Werte nach-berechnen", da habe ich das: 
" temp := (tReal + tImag) / INT_TO_REAL (Auswertung.Anzahl_Werte) ;   // Amplitude des Ausgabe-Wertes
   temp2 := temp * Faktor_Amplitude / Auswertung.Anz_Umdrehungen ;

      IF Auswertung_x2 THEN   // Ausgabe quadrieren ?
         temp2 := temp2 * temp2 / 50.0 ;" 
nicht ganz nachvollziehen können.
Könntest du mir erklären, was an dieser Stelle passiert?

Danke im Voraus
Alex


----------



## fsxela (17 Januar 2014)

Hallo Larry, 
es wäre hilfreich , wenn du nur den FFT-Algorithmus posten würdest. Ich habe leider den Code oben nur zum Teil nachvollziehen können.
Das, mit der Zeitaufnahme und der Drehzahl ist für deine Anwendung angeppast und die Anpassung der Amplitude zur Frequenz in der FFT
etngeht mir vollkommen.

Gruß  
Alex


----------



## Larry Laffer (17 Januar 2014)

Hallo Alex,

der Code steckt da ja drin und geht von "Daten der Messung auswerten" bis "errechnete Werte nach-berechnen".
Das mit der Zeitaufnahme hat damit zu tun, dass ich ja die Werte nur von Zeitpunkt x bis Zeitpunkt y, also während "CMD_Einlesen" bis maximal Array voll ("Daten_Liste_voll := (Index > Anzahl_Werte) OR (Index > Array_max) ;")
So etwas in der Art müßtest du ja auch schon irgendwo haben.
Das Gleiche ist mit der Auswertung. Irgendetwas Aufzeichnen allein macht ja keinen Sinn - man muß es irgendwann einmal auch bewerten.
Etwas anderes wie das habe ich nicht - ich denke mal, dass du ab jetzt da selbst "ein wenig" Hand anlegen mußt - wenn du aber dazu noch weitere Fragen hast ... bitte ...

Gruß
Larry


----------



## fsxela (17 Januar 2014)

Hallo Larry,
der Code habe ich ein bischen modernisiert, aber ansosten FFT fast 1:1 von dir übernommen.
die Aufzeichnung läuf bei mir immmer zwischen den Auswertungen. Aufnahmetakt 2 ms -> Abtastfrequenz 500Hz, mit N= 512, habe Frequenzauflösung 
500Hz/512 = 0,9766.. (vorerst ohne Zeitaufname - es ist eine superidee! - die Drehzahl muss konstant sein) Mit dem Wert korriegiere ich meine die Amplitude, bekomme kein zufriedenstellendes Ergebnis :-( .
Ich melde mich sobald der Fehler gefunden ist.
Gruß
Alex


----------



## Larry Laffer (17 Januar 2014)

OK ... du willst das zyklisch haben - klar.
Bei mir war das so, dass der Messvorgang ereignisgesteuert im Ablauf stattgefunden hat - also Station starten, die misst dann, wertet das, speichert die Ergebnisse und meldet sich zurück für einen neuen Start - Rundschalttisch.

Ich würde mich auf jeden Fall aber für dein Code-Ergebnis interessieren - quasi so im Gegenzug ... (und auch für das Ergebnis deiner "Forschungen" - also die Anwendbarkeit bei dir).

Gruß
Larry


----------



## fsxela (3 Februar 2014)

Hallo Larry
habe als Lösung meines Problems die Skalierung der X-Achse passend zu Delta-Frequenz in WinCC RunTime angewendet – leider gibt es keine andere Lösung. Die Alternative wäre Weckalarm OB so aufzurufen, dass die Delta-Frequenz die ganze Zahl wäre, aber leider geht es mit der Siemens-PLC nicht.
Gruß
Alex


----------

