Step 7 S7 Geht in Stop

Burkhard

Level-2
Beiträge
161
Reaktionspunkte
2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo S7 Programmierer,

ich habe in einem bestehenden Anlagen-Programm eine Baustein (FB) zur Mittelwertglättung eingefügt und im OB1 zweimal aufgerufen. Dabei wurden jeweils zwei Datenbausteine (DB) erzeugt. Als ich dann den OB1, den FB und die zwei DB in die SPS geladen habe, ging diese auf STOP.

Ich hatte keine Zeit für eine Diagnose, da die Maschine weiter produzieren muss. So habe ich einfach den originalen OB1 wieder in die SPS geladen und dann lief die Maschine wieder.

Hat einer eine grundsätzliche Idee, warum das passieren kann? Falls es an einer fehlerhaften Logik im FB liegen sollte (zB schreiben über Arraygrenzen hinaus), würde ich erstmal eine leeren FB benutzen und die Struktur aus FB, 2x DB und OB1-Aufruf in die SPS laden und die Logik dann Schritt für Schritt in den FB einfügen um zu sehen woran das liegen könnte.

Könnte es aber noch was anderes sein?
 
Zuletzt bearbeitet:
ich habe in einem bestehenden Anlagen-Programm eine Baustein (FB) zur Mittelwertglättung eingefügt und im OB1 zweimal aufgerufen. Dabei wurden jeweils zwei Datenbausteine (DB) erzeugt. Als ich dann den OB1, den FB und die zwei DB in die SPS geladen habe, ging diese auf STOP.

Ich hatte keine Zeit für eine Diagnose, da die Maschine weiter produzieren muss. So habe ich einfach den originalen OB1 wieder in die SPS geladen und dann lief die Maschine wieder.

Hat einer eine grundsätzliche Idee, warum das passieren kann? Falls es an einer fehlerhaften Logik im FB liegen sollte (zB schreiben über Arraygrenzen hinaus), würde ich erstmal eine leeren FB benutzen und die Struktur aus FB, 2x DB und OB1-Aufruf in die SPS laden und die Logik dann Schritt für Schritt in den FB einfügen um zu sehen woran das liegen könnte.

Könnte es aber noch was anderes sein?
Vermutlich hättest Du zuerst die beiden DB und den FB laden müssen und erst danach den geänderten OB1.

"Keine Zeit für Diagnose": das Sichern des Diagnosepuffers dauert nichtmal 1 Minute - soviel Zeit ist immer. Besonders wenn man die CPU gerade selber abgeschossen hat und sowieso mit dem PG an der CPU hängt.

Vielleicht hat auch alles überhaupt nicht zusammengepasst oder es war eine Endlosschleife dabei?? Meine Glaskugel schläft schon.
Tip: Beim nächsten Rumspielen an laufenden Anlagen die Änderungen besser VORHER in PLCSIM austesten.

Harald
 
Zuviel Werbung?
-> Hier kostenlos registrieren
PS: Vermutlich kannst Du auch jetzt noch nachträglich in dem CPU-Diagnosepuffer die Stop-Ursache nachlesen, es sei denn, Dein aktuelles Programm müllt den Diagnosepuffer mit Fehlereinträgen voll.

Harald
 
Danke fuer den Tipp mit PLCSIM. Das mache ich jetzt gerade und ich glaube ich hatte wirklich einen Fehler in der Reihenfolge gemacht in der ich die Bausteine in die SPS geladen habe.
 
Hallo,
grundsätzlich habe ich das gleiche Problem mit der Glaskugel wie auch schon Harald - aber trotzdem einen etwas anderen Ansatz :
Je nachdem, wie du das mit deiner Mittelwert-Glättung gemacht hast (ein Programm-Auszug wäre hier hilfreich) könnte es auch zu einer Zykluszeit-Überschreitung gekommen sein (da du ja nicht in der Diagnose nach dem Fehlergrund geschaut hast). Es kann dir also wieder passieren - es sei denn, du gehst da etwas anders ran ...

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich habe den Baustein erstmal leer gemacht und dann downgeloaded. Jetzt geht zumindest die SPS nicht mehr in Stop.

Aber ich komme mit dieser kryptischen AWL Programmierung der S7 gar nicht gut klar. Mit Beckhoff habe ich sowas im ST in nullkommnix programmiert. Aber das Siemens PG das ich habe, hat keine Siemens ST Programmierpsrache installiert. Und bis die bestellt und geliefert wird vergehen Wochen!

Ich versuche einfach den Inputwert auf ein Array-Element 1 zu schreiben und dann die Werte weiter zu schieben. Aber so wie ich das sehe klappt das nicht. Die Werte werden nicht weiter geschoben. Das sehe ich an den Online-Anzeigen.

Im Moment kopiere ich den Eingang auf den Ausgang und versuche parallel das Schieberegister in Betrieb zu nehmen. Darum die Struktur so wie sie ist.

FUNCTION "MovingAverage" : VOID
TITLE =
VERSION : 0.1


VAR_INPUT
Input : REAL ;
END_VAR
VAR_OUTPUT
Output : REAL ;
END_VAR
VAR_TEMP
Buffer : ARRAY [1 .. 10 ] OF REAL ;
MemReal : REAL ;
END_VAR
BEGIN
NETWORK
TITLE =


// Shift the buffer elements to the right, beginning with the last elements

L #Buffer[9];
T #Buffer[10];

L #Buffer[8];
T #Buffer[9];

L #Buffer[7];
T #Buffer[8];

L #Buffer[6];
T #Buffer[7];

L #Buffer[5];
T #Buffer[6];

L #Buffer[4];
T #Buffer[5];

L #Buffer[3];
T #Buffer[4];

L #Buffer[2];
T #Buffer[3];

L #Buffer[1];
T #Buffer[2];

// load the input value into the first array element
L #Input;
T #Buffer[1];

NETWORK
TITLE =

L #Input;
T #Output;


END_FUNCTION
 
Zuletzt bearbeitet:
Das die Arrays nicht gefüllt werden ist recht einfach: Dein Array ist Temporär, daher in jedem neuen Zyklus leer.

Lege das ganze als einen FB an und Speicher deine Variablen in einer Instanz.
 
Zuletzt bearbeitet:
Das verstehe ich! Man müsste das Array als STATIC deklarieren. Das geht wohl nur mit dem FB und dem dazugehörigen DB? Dann probiere ich das. Danke sehr.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Das verstehe ich! Man müsste das Array als STATIC deklarieren. Das geht wohl nur mit dem FB und dem dazugehörigen DB? Dann probiere ich das. Danke sehr.

... oder als Multiinstanz eines Übergordneten Bausteins. Dabei wird dann der Instanz DB einfach in den übergeordneten DB integriert.

Bei Siemens müssen Generell alle Variablen die länger als den aktuellen Zyklus halten sollen in Datenbausteine geschrieben werden.
 
... oder als Multiinstanz eines Übergordneten Bausteins. Dabei wird dann der Instanz DB einfach in den übergeordneten DB integriert.

Bei Siemens müssen Generell alle Variablen die länger als den aktuellen Zyklus halten sollen in Datenbausteine geschrieben werden.

Ob Ihm das viel weiter hilft?
siehe ...
Aber ich komme mit dieser kryptischen AWL Programmierung der S7 gar nicht gut klar. Mit Beckhoff habe ich sowas im ST in nullkommnix programmiert. Aber das Siemens PG das ich habe, hat keine Siemens ST Programmierpsrache installiert. Und bis die bestellt und geliefert wird vergehen Wochen!

Auch könnte er die Variablen im Merker schreiben, dann wären diese auch Remanent (ggf. in der HW Konfig je nach Steuerung noch einstellen) ...
 
Wie kann ich in der AWL Sprache mehrere Additionen in ein Netzwerk packen?

L Signal1
L Signal2
+I
T Ergebnis

L Signal 3
L Ergebnis
+I
T Ergebnis

usw...

Ich will nun noch weitere Additionen in das Netzwerk packen aber er nimmt immer nur die erste Addition und ignoriert die weiteren. Das sehe ich, wenn ich aus dem FB eine Source erzeuge. Da ist dann nur die erste Addition enthalten und die folgenden sind alle weg!

Gibt es da irgend ein Schluesselwort was ich dazwischen schreiben muss?
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Auch könnte er die Variablen im Merker schreiben, dann wären diese auch Remanent (ggf. in der HW Konfig je nach Steuerung noch einstellen) ...

Wenn er nicht vor hätte, den Baustein 2 mal zu benutzen, würde ich glatt zustimmen. Zudem verdränge ich gerne die Existenz von Merkern:p
 
Hattest Du den Baustein vor dem Erstellen der Source auch mal gespeichert?
Man kann in AWL in einem Netzwerk soviel rechnen wie man will.
Code:
L Signal1
L Signal2
+I
L Signal3
+I
T Ergebnis

Harald
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich habe den FB200 angelegt und in einer passenden FC199 zweimal isntanziiert. Dabei habe ich automatisch zwei DB201 und DB202 angelegt und beide Ergebnisse in den DB200 geschrieben.

Hier ist erstmal das Ergebnis. Bitte nicht erschrecken. Ich habe mir vorgenommen mich mit Schleifen in AWL zu befassen.


FUNCTION_BLOCK "MovingAverage"
TITLE =
VERSION : 0.1


VAR_INPUT
Input : REAL ;
END_VAR
VAR_OUTPUT
Output : REAL ;
END_VAR
VAR
Buffer : ARRAY [1 .. 100 ] OF REAL ;
Mem : REAL ;
END_VAR
BEGIN
NETWORK
TITLE =
//Shift the values in the buffer to the right beginning with the right value
//90

L #Buffer[99];
T #Buffer[100];

L #Buffer[98];
T #Buffer[99];

L #Buffer[97];
T #Buffer[98];

L #Buffer[96];
T #Buffer[97];

L #Buffer[95];
T #Buffer[96];

L #Buffer[94];
T #Buffer[95];

L #Buffer[93];
T #Buffer[94];

L #Buffer[92];
T #Buffer[93];

L #Buffer[91];
T #Buffer[92];

L #Buffer[90];
T #Buffer[91];

// 80
L #Buffer[89];
T #Buffer[90];

L #Buffer[88];
T #Buffer[89];

L #Buffer[87];
T #Buffer[88];

L #Buffer[86];
T #Buffer[87];

L #Buffer[85];
T #Buffer[86];

L #Buffer[84];
T #Buffer[85];

L #Buffer[83];
T #Buffer[84];

L #Buffer[82];
T #Buffer[83];

L #Buffer[81];
T #Buffer[82];

L #Buffer[80];
T #Buffer[81];

// 70
L #Buffer[79];
T #Buffer[80];

L #Buffer[78];
T #Buffer[79];

L #Buffer[77];
T #Buffer[78];

L #Buffer[76];
T #Buffer[77];

L #Buffer[75];
T #Buffer[76];

L #Buffer[74];
T #Buffer[75];

L #Buffer[73];
T #Buffer[74];

L #Buffer[72];
T #Buffer[73];

L #Buffer[71];
T #Buffer[72];

L #Buffer[70];
T #Buffer[71];

// 60
L #Buffer[69];
T #Buffer[70];

L #Buffer[68];
T #Buffer[69];

L #Buffer[67];
T #Buffer[68];

L #Buffer[66];
T #Buffer[67];

L #Buffer[65];
T #Buffer[66];

L #Buffer[64];
T #Buffer[65];

L #Buffer[63];
T #Buffer[64];

L #Buffer[62];
T #Buffer[63];

L #Buffer[61];
T #Buffer[62];

L #Buffer[60];
T #Buffer[61];


// 50

L #Buffer[59];
T #Buffer[60];

L #Buffer[58];
T #Buffer[59];

L #Buffer[57];
T #Buffer[58];

L #Buffer[56];
T #Buffer[57];

L #Buffer[55];
T #Buffer[56];

L #Buffer[54];
T #Buffer[55];

L #Buffer[53];
T #Buffer[54];

L #Buffer[52];
T #Buffer[53];

L #Buffer[51];
T #Buffer[52];

L #Buffer[50];
T #Buffer[51];

// 40
L #Buffer[49];
T #Buffer[50];

L #Buffer[48];
T #Buffer[49];

L #Buffer[47];
T #Buffer[48];

L #Buffer[46];
T #Buffer[47];

L #Buffer[45];
T #Buffer[46];

L #Buffer[44];
T #Buffer[45];

L #Buffer[43];
T #Buffer[44];

L #Buffer[42];
T #Buffer[43];

L #Buffer[41];
T #Buffer[42];

L #Buffer[40];
T #Buffer[41];

// 30
L #Buffer[39];
T #Buffer[40];

L #Buffer[38];
T #Buffer[39];

L #Buffer[37];
T #Buffer[38];

L #Buffer[36];
T #Buffer[37];

L #Buffer[35];
T #Buffer[36];

L #Buffer[34];
T #Buffer[35];

L #Buffer[33];
T #Buffer[34];

L #Buffer[32];
T #Buffer[33];

L #Buffer[31];
T #Buffer[32];

L #Buffer[30];
T #Buffer[31];

// 20
L #Buffer[29];
T #Buffer[30];

L #Buffer[28];
T #Buffer[29];

L #Buffer[27];
T #Buffer[28];

L #Buffer[26];
T #Buffer[27];

L #Buffer[25];
T #Buffer[26];

L #Buffer[24];
T #Buffer[25];

L #Buffer[23];
T #Buffer[24];

L #Buffer[22];
T #Buffer[23];

L #Buffer[21];
T #Buffer[22];

L #Buffer[20];
T #Buffer[21];

// 10
L #Buffer[19];
T #Buffer[20];

L #Buffer[18];
T #Buffer[19];

L #Buffer[17];
T #Buffer[18];

L #Buffer[16];
T #Buffer[17];

L #Buffer[15];
T #Buffer[16];

L #Buffer[14];
T #Buffer[15];

L #Buffer[13];
T #Buffer[14];

L #Buffer[12];
T #Buffer[13];

L #Buffer[11];
T #Buffer[12];

L #Buffer[10];
T #Buffer[11];

// 00
L #Buffer[9];
T #Buffer[10];

L #Buffer[8];
T #Buffer[9];

L #Buffer[7];
T #Buffer[8];

L #Buffer[6];
T #Buffer[7];

L #Buffer[5];
T #Buffer[6];

L #Buffer[4];
T #Buffer[5];

L #Buffer[3];
T #Buffer[4];

L #Buffer[2];
T #Buffer[3];

L #Buffer[1];
T #Buffer[2];
NETWORK
TITLE =Write Input to Buffer

L #Input;
T #Buffer[1];
NETWORK
TITLE =
//Summarization of all buffer elements
L #Buffer[1];
L #Buffer[2];
+I ;
T #Mem;


NETWORK
TITLE =

L #Mem;
L 1.000000e+002;
/R ;
T #Output;

END_FUNCTION_BLOCK
 
Also bei einem Array mit 100 Elementen würde ich nicht umspeichern, sondern das Array als Ringpuffer mit einem Schreibpointer (Index) benutzen.
Für die Addition empfiehlt sich aber tatsächlich eine Schleife.

Tipp: Programmcode läßt sich besser formatiert in einem Beitrag posten, wenn man ihn in [CODE]-Tags einfügt. Dafür im Beitragseditor den #-Button benutzen oder die Tags manuell schreiben.

Harald
 
A-Hämmm ...
Darf ich mal fragen, warum du dir das überhaupt so umständlich machst ?

Eine simple Glättung würde so gehen :
L #Glättung
L 1.0
-R
T #hm_Glättung


L #myErgebnis
L #hm_Glättung
*R
L #Messwert
+R
L #Glättung
/R
T #myErgebnis
Alle Variablen wären vom Typ REAL - myErgebnis muss in einem statischen Speicher sein.

Diese Berechnung würde auch keine Zykluszeit-Überschreitung erzeugen ...

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Vielen Dank für die hilfreichen Antworten. Mein FB zur Mittelwertglaettung funktioniert nun. Ich habe ihn zweimal instanziiert und das ganze Prinzip mit den Datenbaustein usw. kapiert. Ist schon alles ziemlich anders als bei Beckhoff TwinCat.

Meiner Ansicht nach muss ein Baustein zur gleitenden Mittweltwerbildung aus einem Ringpuffer-Schieberegister, einem Eingangswert-Transfer in das erste Ringpuffer-Element und einer Ringpuffer-Aufsummierung + Division durch die Elementanzahl bestehen, darum habe ich diese drei Elemente genau so abgebildet. Mit ST geht das auch relativ schnell mit wenig Zeilen. In AWL braucht es mehr Zeilen vor allem wenn man auf Schleifen verzichtet.

Ein Wort noch zur Programmierung mit der Siemens S7 PLC und dem S7 Manager. Ich muss das Arbeitsprinzip kritisieren. Mit der S7 ist es möglich einen einzelnen FB oder FC-Baustein in die SPS zu laden, der zB einen Datenbaustein referenziert, der noch NICHT in die SPS geladen wurde. Das ist sehr gefährlich, denn die SPS geht dann wieder auf STOP. Dieser Flüchtigkeitsfehler ist mir erneut passiert.

Bei Beckhoff TwinCat ist das vom Arbeitsprinzip her gar nicht möglich und funktioniert viel mehr wie bei einer richtigen Programmiersprache. Das ganze Projekt wird nach einer Änderung kompiliert und auf Syntax und Referenzfehler geprüft und die Differenz dann mittels Online-Change in die SPS downgeloaded. Ein laden einzelner Bausteine und ein STOP der SPS auf Grund einer fehlerhaften Referenz ist hier gar nicht möglich.

Ich finde die S7 und den S7 Manager im Vergleich zur TwinCat Beckhoff SoftSPS wie aus einer anderen Zeit.
 
Zuletzt bearbeitet:
Meiner Ansicht nach muss ein Baustein zur gleitenden Mittweltwerbildung aus einem Ringpuffer-Schieberegister, einem Eingangswert-Transfer in das erste Ringpuffer-Element und einer Ringpuffer-Aufsummierung + Division durch die Elementanzahl bestehen, darum habe ich diese drei Elemente genau so abgebildet. Mit ST geht das auch relativ schnell mit wenig Zeilen. In AWL braucht es mehr Zeilen vor allem wenn man auf Schleifen verzichtet.


Nein, muss er nicht - der oben von mir gepostete Code funktioniert genauso (und auch genauso gut).

Du darfst ST und AWL nicht auf eine Stufe stellen - speziell nicht bei so etwas. Bei Siemens gäbe es ja auch SCL (ich weiß - hast du nicht) - damit könntest du es in etwa genau so wie in ST machen (und auch da genauso auch nur mit ein paar Zeilen).

Gruß
Larry
 
Zurück
Oben