TIA Bit Maskierung AWL in SCL

[SalvatoreDC]

Um das Ganze nochmal zu formulieren, da ich den Code in Zukunft anpassen soll, (z.b mehr oder weniger Schieber) dachte mir ein Code zu realisieren die in Zukunft ganz einfach erweitern oder reduzieren kann.
Zum Beispiel hier ein Pseudo-Code was ich damit meine:

// Deklarationen
// ARRAY [1..14] OF BYTE (oder ARRAY [1..14] OF BOOL bei Verwendung einzelner Bits)
#IB_Schieber // Eingänge (ein Byte pro Schieber oder Array von BOOL)
// ARRAY [1..8] OF WORD (8 WORD, um 14 Schieber abzudecken, wir verwenden nur einen Teil einiger WORD)
#0_Schieber // Ausgänge/Zustand (WORD pro Schieber)
// ARRAY [1..16] OF WORD (Masken für SET)
#Maschere_Set

// Initialisierung der Masken (einmalig, z.B. in OB100)
#Maschere_Set[1] := W#16#0001; // Bit 0
#Maschere_Set[2] := W#16#0002; // Bit 1
#Maschere_Set[3] := W#16#0004; // Bit 2
#Maschere_Set[4] := W#16#0008; // Bit 3
#Maschere_Set[5] := W#16#0010; // Bit 4
#Maschere_Set[6] := W#16#0020; // Bit 5
#Maschere_Set[7] := W#16#0040; // Bit 6
#Maschere_Set[8] := W#16#0080; // Bit 7
#Maschere_Set[9] := W#16#0100; // Bit 8
#Maschere_Set[10] := W#16#0200; // Bit 9
#Maschere_Set[11] := W#16#0400; // Bit 10
#Maschere_Set[12] := W#16#0800; // Bit 11
#Maschere_Set[13] := W#16#1000; // Bit 12
#Maschere_Set[14] := W#16#2000; // Bit 13
#Maschere_Set[15] := W#16#4000; // Bit 14
#Maschere_Set[16] := W#16#8000; // Bit 15

#T_FRG_Ventile // Wenn es ein globales Signal ist

// Beginn des Netzwerks (in einen zyklischen OB, z.B. OB1)
FOR #i := 1 TO 14 DO

    A #I_Schieber[#i] // Lese den entsprechenden Eingang
    A #T_FRG_Ventile // Zusätzliche Bedingung (falls erforderlich)
    JCN sb[#i]

    L #IB_Schieber[#i] // Lade den Eingang
    L BYTE#16#01 // Maske zum Überprüfen des Bits 0 des Eingangs (passe an, wenn nötig)
    AW
    JZ sb[#i]

    // SET-Teil (Verwende OR auf WORD)
    L #0_Schieber[#i]
    L #Maschere_Set[#i]
    OW
    T #0_Schieber[#i]
    JU se[#i]

sb[#i]:
    // RESET-Teil (Verwende AND mit NOT auf WORD)
    L #0_Schieber[#i]
    L #Maschere_Set[#i]
    NOT // Komplementiere die Maske
    AW
    T #0_Schieber[#i]

se[#i]:
    NOP 0

END_FOR

Damit könnte ich alles in ein Netzwerk implementieren und in Zukunft einfach die Nummer von Schieber ändern anstatt ein Netzwerk pro Schieber jedes mal.

Ist das möglich? Danke an alle

 

[Onkel Dagobert]

Hallo Slvadore,

geht es dir ernsthaft darum, ein paar Schieber anzusteuern? Dann solltest du dir einen FB basteln, der dieses für einen einzigen Schieber tut, und diesen dann als Instanzen aufrufen. Diese Sieben-auf-einen-Streich-Methode finde ich für so etwas völlig fehl am Platz. Vielleicht beschreibst du uns erst einmal in Stichpunkten, welche Funktionen realisiert werden sollen.

Oder ist es einfach nur eine Programmierübung zum Ausmaskieren?

 

[sps_klassik]

Das sehe ich genauso.Hier wird über Programmcode philosophiert und wir wissen nicht was überhaupt passieren soll.

 

[ducati]

Das sehe ich genauso.Hier wird über Programmcode philosophiert und wir wissen nicht was überhaupt passieren soll.

Hier wird über den AWL-Code aus Beitrag #1 philosophiert, und den hat PNDP sehr schön in 5 Zeilen SCL abgebildet...

 

[ducati]

Das Projekt hat ein CPU 1510-SP1-pn.

um bei einer 1500er Bits aus nem Wort zu holen wäre der Slice-Zugriff das Mittel der Wahl.

SIOS

support.industry.siemens.com

#O_Schieber1_16.%X0 := #IW_Schieber1_16.%X0 AND #I_Schieber1_16 AND #T_FRG_Ventile; // Schieber 00
#O_Schieber1_16.%X1 := #IW_Schieber1_16.%X1 AND #I_Schieber1_16 AND #T_FRG_Ventile; // Schieber 01
...

 

[sps_klassik]

Das stelle ich gar nicht in Abrede.Trotzdem finde ich es anderstrum besser.Er sagt was er für eine Funktionalität er braucht und dann wird geantwortet.

 

[SalvatoreDC]

jo, das verwirrt, irgendwie suggeriert das ganze 16 verschiedene Schieber, passt dann aber nicht zum Byte.

Und irgendwie nicht klar, warum das ganze in AWL so kompliziert für jeden Schieber separat gemacht wurde

Ja das würde ich gerne machen, alles in ein Netzwerk und durch eine schleife alle Schieber maskieren. Ich meine Das Programm funktioniert schon wie es ist, nur dass muss ich für jede Schieber das gleiche tuen. Bis jetzt habe ich es nicht geschafft diese code, in anderen Programmiersprache nennt man es "Modularisierung" oder "Kapselung". Wie PN/DP erwähnt hat leider muss Mann eine Sprache gut beherrschen um das gleiche von OOP in PLC code umzuwandeln.

Und nochmal, das ist eine Übungsprojekt die läuft und wurde getestet, und aus Lernzwecke bin hier und frage nach Typs und Hilfen wie kann man es Optimieren da ich ein Netzwerk jedes mal pro Schieber zu verwenden redundant und repetitiv finde.

Nochmal mehr Bilder um es besser darzustellen, ich habe ein FB die FB_Hydraulik genannt und tut auch die Schieber Maskieren:





Wie man sieht von Netzwerk7 zu Netzwerk20 wird die Maskierung für jeden Schieber wiederholt, und wollte eine Method finde um alles in ein Netzwerk zu führen..wie z.b eine Array die durch ein loop aufgerufen wird z.b:

FOR #i := 1 TO 14 DO

    A #I_Schieber[#i]
    A #T_FRG_Ventile
    JCN sb[#i]

    L #IB_Schieber[#i]
    AW
    JZ sb[#i]

    // Parte SET (Usa OR su WORD)
    L #0_Schieber[#i]
    L #Maschere_Set[#i]
    OW
    T #0_Schieber[#i]
    JU se[#i]

sb[#i]:
    // Parte RESET (Usa AND con NOT su WORD)
    L #0_Schieber[#i]
    L #Maschere_Set[#i]
    NOT
    AW
    T #0_Schieber[#i]


se[#i]:
    NOP 0

END_FOR

Etwas änliches, dass ich quasi durch Array und Indizierung das gleich in Loop machen kann, so vermeide ich ein Netzwerk pro Schieber, wenn ich 100 Schieber hätte, wurde den Code sehr repetitiv sein. Oder ist meine Idee falsch?

 

[PN/DP]

Komm auf Hochsprachige Programmiersprache und habe das gleiche in C++ realisiert, kann aber in Tia nicht das gleiche durch For-loop and Array realisieren.

Um das Ganze nochmal zu formulieren, da ich den Code in Zukunft anpassen soll, (z.b mehr oder weniger Schieber) dachte mir ein Code zu realisieren die in Zukunft ganz einfach erweitern oder reduzieren kann.
(...)
Damit könnte ich alles in ein Netzwerk implementieren und in Zukunft einfach die Nummer von Schieber ändern anstatt ein Netzwerk pro Schieber jedes mal.

Ja die Hochsprachenprogrammierer ... die haben immer keine Lust, etwas fast gleiches dreimal zu tippen und wollen dann Schleifen oder Codeteile irgendwo ableiten oder vererben. Effizienz ist dabei egal - in der Zukunft wird es schon Computer zu kaufen geben, die leistungsstark genug sind, den Code erträglich schnell abzuarbeiten. Selbst wenn sie Aggregate als FB-Objekte programmieren, dann wollen sie nicht ...zig Instanzen einzeln aufrufen, sondern am liebsten Arrays of FB-Instanz, damit die in Schleifen aufgerufen werden können.

So programmiert man aber keine SPS. Da kommt es darauf an, dass im Problemfall unter Zeitdruck bei teilweise noch laufender und teilweise unfreiwillig stillstehender Produktion von beliebigen Programmierern der Programmcode für bestimmte Instanzen leicht beobachtet werden kann und bei Bedarf (z.B. Diagnose) genau eine Instanz ein etwas abweichendes Verhalten/abweichende Verriegelungen gegenüber den anderen Instanzen haben kann. Wenn dann ein Großteil des Codes in Schleifen verarbeitet wird, dann hat ein nicht eingeweihter Programmierer kaum eine Chance, die Stelle zu finden, wo es hakt und wo er (ggf. temporär) etwas überbrücken kann.

 

[Onkel Dagobert]

... So programmiert man aber keine SPS...

Naja, wenn man gewisse Standardroutinen im Hintergrund automatisiert abhandelt, dann gewinnt das Programm aber auch wieder enorm an Übersichtlichkeit. Und man kann sich beim Programmieren voll auf die eigentliche Aufgabe konzentrieren. So etwas muss natürlich gut durchdacht sein.

 

[DCDCDC]

da ich ein Netzwerk jedes mal pro Schieber zu verwenden redundant und repetitiv finde.

Das ist aber in der Steuerungswelt der best practice.. du schreibst eine Funktion und vererbst/referenzierst diese über die einzelnen Instanzen immer weiter.. spart dir Arbeitsspeicher und du bleibst performant und gekapselt.

IEC ist nicht C++, das solltest du akzeptieren und denen vertrauen die das schon jahrelang machen und handhaben..

Natürlich kannst du das alles in einer Funktion abhandeln.. werden aber aus sieben Schiebern auf einmal 20, so bist du mit der gekapselten Variante besser dran.. Netzwerk kopieren und einfach nur die Parameter an der Funktion anpassen, anstatt noch mal Code zu erweitern.. und bitte nicht mit generativen Sprachmodellen.

 

[ducati]

Ja das würde ich gerne machen, alles in ein Netzwerk und durch eine schleife alle Schieber maskieren.

Naja, wenn Du das in einem Netzwerk machen willst, ohne Schleife, dann der SCL Code von PNDP aus Beitrag #5 oder meiner für jedes Ventil einzeln in Betrag #25

Sicherlich geht das sogar auch in FUP.

Wenn Du trotzdem warum auch immer ne Schleife bauen willst, dann informier Dich über AT-Sicht, also Überlagerung des WORD durch ein Array of Bool...

In nen FC oder FB muss man diese kleine Verknüpfung jetzt nicht unbedingt auslagern...

#O_Schieber1_16.%X0 := #IW_Schieber1_16.%X0 AND #I_Schieber1_16 AND #T_FRG_Ventile; // Schieber 00
#O_Schieber1_16.%X1 := #IW_Schieber1_16.%X1 AND #I_Schieber1_16 AND #T_FRG_Ventile; // Schieber 01
...