TIA SCL Word in Schieberegister

[Prism]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo zusammen,
ich habe ein kleines Problem mit meinem Code und ich komme einfach nicht drauf, warum es nicht funktioniert.... Ich hoffe, hier Hilfe zu finden.

Ausgangssituation:
Ich habe ein Fehler Word, dass ich bitweise auslese. Jedes einzelne Bit im Word steht für einen eigenen Fehler und damit eine eigene Fehlermeldung, die in einem Schieberegister ausgegeben werden soll. Das auswerten der einzelnen Bits funktioniert schon. Die korrespondierenden Fehlermeldungen der Bits werden dann in einem String-Array gespeichert, was mich zu meinem Problem führt.



In einer For-Schleife gehe ich die einzelnen Fehlermeldungen durch, die in meinem String-Array "HsAnstehendeFehlermeldung" gespeichert sind. Wenn ein Platz im Array ungleich eines leeren Strings ist, dann wird die Fehlernachricht an dieser Stelle in eine Hilfsvariable "HsFehlerNachricht" geschrieben. Diese Hilfsvariable wird dann in eine Schieberegister-Variavble "StringArrayFehlerNachrichten" geschoben. Mein Problem ist, dass wenn mehrere Bits im Fehler Word auf "TRUE" stehen - nehmen wir mal an es sind zwei, das Schieberegister nur den ersten Fehler schiebt. Der Zweite Fehler, wird zwar in die Variable "StringArrayFehlerNachrichten" auf den Platz [0] geschrieben, jedoch nicht geschoben.

Wenn ich also das Fehler Word zum Beispiel mit dem Dezimalwert "3" steuere, müssten dann letztendlich der Fehler1 und der Fehler2 in das String-Array im Schieberegister geschrieben werden.
Allerdings wird nur die erste Fehlernachricht im Schieberegister geschoben. Die zweite Nachricht bleibt dann in StringArrayFehlerNachrichten[0] liegen. Der String in der Variable StringArrayFehlerNachrichten[0] wird nicht visualisiert und wird nur für das schreiben der Strings in das Schieberegister verwendet.

Meine Frage:
Müsste hier nicht jedes mal die Schleife des Schieberegisters ausgeführt werden, wenn eine Nachricht in der Variable "HsAnstehendeFehlermeldung" steht ?
Ich verstehe nicht ganz, warum nicht alle Fehlermeldungen geschoben werden.


REGION Schieberegister
FOR #j := 0 TO 15 DO

IF #HsAnstehendeFehlermeldung[#j] <> '' THEN

#HsFehlerNachricht := #HsAnstehendeFehlermeldung[#j];


// Hier wird der momentane Fehlerstring in das Schieberegister geschoben
StringArrayFehlerNachrichten[0] := #HsFehlerNachricht ;

// Schieberegister

FOR #k := 1 TO #HiLängeDesFehlerArrays DO

// Hier wird die Nachricht im Schieberegister bewegt
StringArrayFehlerNachrichten[#HiLängeDesFehlerArrays] := StringArrayFehlerNachrichten[#HiLängeDesFehlerArrays - 1];


#HiLängeDesFehlerArrays := #HiLängeDesFehlerArrays - 1;

END_FOR;
#HsFehlerNachricht := '';

// Damit wird das String-Array in dem die Fehlernachrichten ursprünglich gespeichert werden, wieder zurückgesetzt.
#HsAnstehendeFehlermeldung[#j] := '';
END_IF;
END_FOR;

END_REGION


Ich hoffe, ich konnte mein Problem einigermaßen verständlich erklären....

Vielen Dank schon einmal im Voraus!

 

[Oberchefe]

Statt
FOR #k := 1 TO #HiLängeDesFehlerArrays DO

// Hier wird die Nachricht im Schieberegister bewegt
StringArrayFehlerNachrichten[#HiLängeDesFehlerArrays] := StringArrayFehlerNachrichten[#HiLängeDesFehlerArrays - 1];

Muss es
FOR #k := 1 TO #HiLängeDesFehlerArrays DO

// Hier wird die Nachricht im Schieberegister bewegt
StringArrayFehlerNachrichten[#k] := StringArrayFehlerNachrichten[#k - 1];
heißen

 

[Heinileini]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ich hoffe, ich konnte mein Problem einigermaßen verständlich erklären....

Leider hat's für mein Verständnis nicht gereicht.
Wie Du ermittelst, welche Meldung eingetragen werden soll habe ich verstanden.
Wie und wann und wodurch eine im "SchiebeRegister" eingetragene Meldung wieder ausgetragen (gelöscht) werden soll, ist mir nicht klar geworden.
Auch nicht, ob eine noch bzw. bereits eingetragene Meldung ggfs ein weiteres Mal eingetragen werden soll. Ich würde mich dagegen entscheiden.
Ich sehe aber nicht, wie Du verhinderst, dass das SchiebeRegister mit "Redundanz" voll gestopft wird.
Den Sinn eines SchiebeRegisters kann ich auch nicht wirklich nachvollziehen. Ein FIFO wäre m.E. zielführender.

Dass Du in der inneren Schleife nicht mit #k, sondern mit #HiLängeDesFehlerArrays arbeitest, könnte die Ursache dafür sein, dass sich die Software anders verhält, als Du erwartest.

 

[Prism]

Wie und wann und wodurch eine im "SchiebeRegister" eingetragene Meldung wieder ausgetragen (gelöscht) werden soll, ist mir nicht klar geworden.

Die Variable "HiLängeDesFehlerArrays" legt letztlich die Größe des Registers fest. Steht in der Variable z.B. "20", dann können 20 Plätze des String-Arrays "StringArrayFehlerNachrichten" beschrieben werden. Diese Hilfsvariable wird über einen Input am Baustein beschrieben.

Ich will nicht, dass die Meldungen wieder gelöscht werden. Ist das Register voll, dann wird die letzte Fehlermeldung einfach überschrieben, da die Schleife ja alle Fehlermeldungen um eins nach oben rückt.
Wenn die Schleife ausgeführt wird, dann schiebt sich ja die Fehlermeldung auf Platz[0] auf Platz[1], die von Platz[1] auf Platz[2] usw....
In dem String-Array steht also nur die Anzahl der Fehler, die die Variable "HiLängeDesFehlerArrays" zulässt.

Ich sehe aber nicht, wie Du verhinderst, dass das SchiebeRegister mit "Redundanz" voll gestopft wird.
Den Sinn eines SchiebeRegisters kann ich auch nicht wirklich nachvollziehen. Ein FIFO wäre m.E. zielführender.

Wenn Du mit "Redundanz" meinst, dass das komplette String-Array von einer Fehlermeldung belegt wird, dann wird das durch folgenden Programmteil verhindert:

IF #HsAnstehendeFehlermeldung[#j] <> '' THEN
.
.
.
// Damit wird das String-Array in dem die Fehlernachrichten ursprünglich gespeichert werden, wieder zurückgesetzt.
#HsAnstehendeFehlermeldung[#j] := '';
END_IF;

Die Schleife wird ja nur ein einziges mal aufgerufen da der Fehlerstring in der Hilfsvariable #HsAnstehendeFehlermeldung[#j] ja am ende der IF-Abfrage wieder "geleert" wird. Dadurch wird der String auch nur ein einziges mal geschrieben.

Ursprünglich habe ich vor dem Register noch eine "Trigger-Flanke" gehabt. Die IF-Abfrage reicht jedoch. Das Schieberegister funktioniert auch nach meinen Vorstellungen... nur eben nicht, wenn mehrere Bits im Fehler-Word "TRUE" sind. Dann wird nur die Fehlermeldung des ersten Bits geschoben. Ich glaube, dass die FOR-Schleife aus irgend einem Grund nur einmal ausgeführt wird.

Im Grunde ist das ja ein FIFO... zumindest wenn meine Recherche dazu korrekt war...

 

[Prism]

Dass Du in der inneren Schleife nicht mit #k, sondern mit #HiLängeDesFehlerArrays arbeitest, könnte die Ursache dafür sein, dass sich die Software anders verhält, als Du erwartest.

Das war das Problem. Ich habe jetzt mal versucht, die Variable, die die Länge des Registers begrenzt, vor der Schleife zuzuweisen. Jetzt funktioniert es einwandfrei.

Vielen Dank für die schnelle Hilfe!