# SCL mit langen Bitverknüpfungen



## COCO-RB (20 September 2017)

Hallo, ich bin in der SCL-Programmierung noch neu. Ich habe angefangen einen Baustein von AWL nach SCL umzuschreiben. Soweit seiht das im TIA-Portal V14 ja auch ganz übersichtlich aus. Bei den längeren Logikverknüpfungen bin ich mir aber noch etwas unsicher. Ich habe die Onlinehilfe dazu gelesen, finde bei Siemens außer der Beschreibung aber kaum Beispiele.

Operatoren und ihre Auswertungsreihenfolge
Ausdrücke können durch Operatoren miteinander verknüpft oder ineinander geschachtelt sein. 
Die Reihenfolge der Auswertung von Ausdrücken hängt von der Rangfolge der Operatoren und der Klammerung ab. Grundsätzlich gelten folgende Regeln:


Arithmetische Operatoren werden vor Vergleichsoperatoren und diese vor logischen Operatoren ausgewertet.
Gleichrangige Operatoren werden nach ihrem Auftreten von links nach rechts ausgewertet.
Wertzuweisungen werden von rechts nach links ausgewertet.
Operationen in Klammern werden zuerst ausgewertet.

// Auszug in AWL

  U     #inout_Bereich_Ende
      O(
      UN    #stat_Regler.ProgPos.Steuerwort."2_Bit_00_M090_PLC_Kanal_0"
      UN    #stat_Regler.ProgPos.Steuerwort."2_Bit_01_M091_PLC_Kanal_1"
      UN    #stat_Regler.ProgPos.Steuerwort."2_Bit_02_M092_PLC_Kanal_2"
      UN    #stat_Regler.ProgPos.Steuerwort."2_Bit_03_M093_PLC_Kanal_3"
      UN    #stat_Regler.ProgPos.Steuerwort."2_Bit_04_M094_PLC_Kanal_4"
      UN    #stat_Regler.ProgPos.Steuerwort."2_Bit_05_M095_PLC_Kanal_5"
      )
      U     #in_Standby_erlauben
      O     #in_Halt_Vorschub
      UN    #in_Tippen_plus
      UN    #in_Tippen_minus
      UN    #in_Referenzfahrt_starten
      U     #stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit"
      =     #stat_Verz_StandBy.VAR_IN

// Auszug in SCL

 #stat_Verz_StandBy.VAR_IN := (
        (#stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit" AND
        NOT #in_Referenzfahrt_starten AND
        NOT #in_Tippen_minus AND
        NOT #in_Tippen_plus) AND
    #in_Halt_Vorschub OR
    #in_Standby_erlauben AND
        ((NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_00_M090_PLC_Kanal_0"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_01_M091_PLC_Kanal_1"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_02_M092_PLC_Kanal_2"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_03_M093_PLC_Kanal_3"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_04_M094_PLC_Kanal_4"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_05_M095_PLC_Kanal_5")
        OR #inout_Bereich_Ende));

Ist die Umsetzung Richtig oder gibt es auch eine einfachere Lösung?
Kennt Ihr Beispiele zu solchen Umsetzungen Vergleich AWL / SCL Programmierung?

Vielen Dank!


----------



## blackpeat (20 September 2017)

Auf die Schnelle fällt mir nur ein das vielleicht in mehrere Teile zu Teilen mit temporären Variablen. Das könnte dann etwas lesbarer werden.


----------



## rostiger Nagel (20 September 2017)

Ich finde in deinen Beispiel keinen Unterschied hinsichtlich der Lesbarkeit,
allerhöchstens hätte ich bei SCL das "AND" vor den zeilenubruch mit in die
Folgende Zeile genommen. 

Das unleserliche kommt von den langen Variablen, die könntest du ja Temponär
auf kürze umlade oder über die Bausteinschnittstelle in kurze Variablen wandeln.


----------



## COCO-RB (20 September 2017)

Hallo,

vielen Dank für die Antworten!

Ich denke ein umkopieren um kürzere Texte zu erhalten ist eher unpraktisch. Ich möchte ja die Symbolischen Namen sehen und nicht eine Abkürzung oder einen Stellvertreter.
Die Position der Verknüpfung am Zeilenanfang ist eine gute Idee, ich habe auch einen zusammengehörigen Block nach innen gerückt.

Wenn man lange in AWL gearbeitet hat, ist das lesen der Verknüpfung von Rechts nach Links sehr ungewohnt, gerade wenn durch die langen Symbolischen Variablen am Ende oft nur wenige Variablen hintereinander stehen. Es ja so als müsste man von unten nach oben lesen und dann auch noch die Rangfolge beachten. Das mit der Rangfolge führt ja auch zu mehr Klammern.

Ich werde mit diesen Zeilen mal ein Testprogramm schreiben um zu prüfen ob die Logik dann das gleiche wie die AWL Zeilen macht.

Zusätzlich habe ich auch eine Frage an den Siemens Support gestellt, wenn es eine gute Antwort gibt werde ich mich melden.
Es ist mir halt wichtig, einen fehlerfreien und gut lesbaren Code zu schreiben. Wenn ich mal mehr in SCL mache möchte ich nicht ständig nacharbeiten oder andere Überraschungen erleben.

Schöne Grüße,
COCO


 #stat_Verz_StandBy.VAR_IN := (
        (#stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit" AND
        NOT #in_Referenzfahrt_starten AND
        NOT #in_Tippen_minus AND
        NOT #in_Tippen_plus)
    AND #in_Halt_Vorschub
    OR #in_Standby_erlauben
        AND ((NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_00_M090_PLC_Kanal_0"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_01_M091_PLC_Kanal_1"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_02_M092_PLC_Kanal_2"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_03_M093_PLC_Kanal_3"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_04_M094_PLC_Kanal_4"
        AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_05_M095_PLC_Kanal_5")
    OR #inout_Bereich_Ende));


----------



## Ralle (20 September 2017)

Wenn das zuviel wird (Kann bei Handling-Freigaben schon mal kompliziert werden), dann kann man ja durchaus ein Stück Code in einen AWL- oder KOP/FUP-Baustein auslagern und sich das Ergebnis zurück holen.
Besonders Verschachtelungen sind schnell unübersichtlich.


----------



## COCO-RB (20 September 2017)

ich habe jetzt mal einen Test der SCL im Vergleich zu den AWL Zeilen gemacht. Wenn die letzte UND-Verknüpfung "..._Einschaltbereit" ein 0-Signal hat, muss das Ergebnis auch Null haben!

U     #stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit"
      =     #stat_Verz_StandBy.VAR_IN

Mit dem SCL-Code erhalte ich aber eine 1.

Was mache ich falsch? Oder muss der die SCL-Zeile nicht von Rechts nach Links gelesen werden?


----------



## weißnix_ (20 September 2017)

Ich lese SCL-Zeilen von Links nach rechts (Ausgehend von der Zuweisung). Und weil mir das irgendwie seltsam vorkam, hab ich das mal nachgebastelt, was ich lese.

Oben der AWL-Code, unten der SCL-Code:



Ich erhebe nicht den Anspruch auf Richtigkeit!


----------



## COCO-RB (20 September 2017)

ok, danke für deine Überlegungen!

Gleichrangige Operatoren werden nach ihrem Auftreten von links nach rechts ausgewertet.Wertzuweisungen werden von rechts nach links ausgewertet.

Die Erklärung, ohne Beispiel, von Siemens hat mich vermutlich auf den falschen Pfad gebracht.

Wie würde dann eine gleichwertige SCL Zuweisung aussehen?
Ich werde jetzt auch mal in die Richtung links nach rechts testen.


----------



## Onkel Dagobert (20 September 2017)

rostiger Nagel schrieb:


> Ich finde in deinen Beispiel keinen Unterschied hinsichtlich der Lesbarkeit...


Das sehe ich auch so. Diese wechselseitigen UND und ODER Verknüpfungen sind sowohl in AWL als auch in SCL eine Katastrophe. Wenn es unbedingt in SCL oder AWL sein muss, dann in diesem Fall vielleicht besser mit Zwischenergebnissen als mit Klammerebenen arbeiten. Wenn ich mich nicht täusche, muss der SCL-Code mit Klammerebenen mit drei Klammern beginnen. Hab's aber nicht getestet und erhebe auch keinen Anspruch auf Richtigkeit.

Auf die Antwort von Siemens wäre ich mal gespannt. Gibt sich der Support wirklich mit so etwas ab?
Im TIA-Portal der aktuellen Version kannst du übrigens in FUP-Bausteinen auch AWL- und SCL-Netzwerke einfügen, zumindest bei der 1500. Das ist für so etwas nicht uninteressant.


----------



## weißnix_ (20 September 2017)

So und jetzt hänge ich mich noch weiter raus und präsentiere meine Variante des Code-Äquivalents:


```
#stat_Verz_StandBy.VAR_IN:=

(#inout_Bereich_Ende or (
not #stat_Regler.ProgPos.Steuerwort."2_Bit_00_M090_PLC_Kanal_0" 
and not #stat_Regler.ProgPos.Steuerwort."2_Bit_01_M091_PLC_Kanal_1"
and not #stat_Regler.ProgPos.Steuerwort."2_Bit_02_M092_PLC_Kanal_2"
and not #stat_Regler.ProgPos.Steuerwort."2_Bit_03_M093_PLC_Kanal_3"
and not #stat_Regler.ProgPos.Steuerwort."2_Bit_04_M094_PLC_Kanal_4"
and not #stat_Regler.ProgPos.Steuerwort."2_Bit_05_M095_PLC_Kanal_5"
)
and #in_Standby_erlauben
or #in_Halt_Vorschub)
and not #in_Tippen_plus
and not #in_Tippen_minus
and not #in_Referenzfahrt_starten
and #stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit"
;
```

Und ja: Dafür hab ich jetzt 20 Minuten gebraucht und 2 Tassen kalten Kaffee von heute morgen :shock:

Edit2: schnell noch finales Semikolon rein, bevor es einer merkt


----------



## COCO-RB (20 September 2017)

danke für deine Bemühungen, echt super!
Ich habe den Code getestet, alles ok!

Alternativ hatte ich schon eine Version getestet, bei der ich nach jeder Anweisung eine Klammer setze.
Dann kann zwar in der Reihenfolge wie bei AWL programmiert werden, das sieht aber unübersichtlich aus!

Ich denke das größte Problem war mein falscher Ansatz, von rechts nach links zu lesen!
Das sollte in der Onlinehilfe besser mit einem Beispiel erklärt werden.

  #stat_Verz_StandBy.VAR_IN := ((((((#inout_Bereich_Ende
    OR (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_00_M090_PLC_Kanal_0"
    AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_01_M091_PLC_Kanal_1"
    AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_02_M092_PLC_Kanal_2"
    AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_03_M093_PLC_Kanal_3"
    AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_04_M094_PLC_Kanal_4"
    AND NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_05_M095_PLC_Kanal_5")
    AND #in_Standby_erlauben)
    OR #in_Halt_Vorschub)
    AND NOT #in_Tippen_plus)
    AND NOT #in_Tippen_minus)
    AND NOT #in_Referenzfahrt_starten)
    AND #stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit");

Deinen Vorschlag werde ich in der Software beim Kunden Morgen übernehmen, nochmal vielen Dank!


----------



## COCO-RB (20 September 2017)

ich habe die Änderung im Programm (für Morgen) schon einmal übernommen. Dabei habe ich mir meine erste Version dieser Verknüpfung noch einmal angesehen.

Da hatte ich von links nach rechts gelesen, ist ja auch einfacher zu lesen! Ich bin erst mit den Anpassungen angefangen, als es nicht gleich lief.
(da fehlte dann ja nur eine Klammer nach der OR Anweisung)


----------



## rostiger Nagel (20 September 2017)

Also ganz ehrlich das mit den Klammern macht es nicht wirklich übersichtlich,
wenn schon nicht kurz dann vielleicht wirklich mal ein paar temporäre Zwischenergebnisse 
erzeugen. Deine folgenden Kollegen und Kunden werden es dir danken. 
Da sind doch ein paar gleichartige Signale wie die von den Reglern, Tippen ...


----------



## weißnix_ (20 September 2017)

@rostiger Nagel
Es stand vermutlich der Vorsatz dahinter, den effizienten AWL-Code in effizienten SCL-Code zu überführen.
Ich fände schon Zwischenergebnisse bei der AWL-VAriante besser.

Codeeffizienz bemisst sich heute nicht an der Speichergröße und kaum an der Ausführungsgeschwindigkeit. Die Lesbarkeit sollte vornedran gerückt sein...

@COCO-RB

Wertzuweisungen von rechts nach links- Da ist sowas gemeint:
var_a:=var_b:=var_c:=var_d:=true;


----------



## COCO-RB (21 September 2017)

der letzte Vorschlag hat leider nicht funktioniert, in der Simulation hatte ich wohl nicht genug getestet.




Ich habe aber eine Lösung gefunden, der SCL-Code muss bei der Wertzuweisung aber von Rechts nach Links gelesen werden!
Das ist dann so als würde der AWL-Code von unten nach oben geschrieben.




Von Siemens kam nur die Empfehlung einen SCL-Kurs zu besuchen!
Ich denke der kostenlose Support ist damit Überfordert!

Mit unserem Siemens Vertriebspartner habe ich jetzt einen SCL Workshop abgesprochen.
(ein Tag ist im Werk kostenlos, vermutlich müssen wir aber auch mal Kurse belegen)


----------



## Ralle (21 September 2017)

Aber das Einklammern mache ich in SCL schon immer, aus Gewohnheit. Wahrscheinlich ist mit das deshalb noch nie wirklich aufgefallen.


----------



## holgermaik (21 September 2017)

> der SCL-Code muss bei der Wertzuweisung aber von Rechts nach Links gelesen werden!


Ich denke da machst du einen Fehler


> Gleichrangige Operatoren werden nach ihrem Auftreten von links nach rechts ausgewertet.





> (#inout_Bereich_Ende or (


Da "inout_Bereich_Ende" bereits True ist wird die weitere Abarbeitung hier abgebrochen und das Ergebnis ist True.

Habe eben kein SCL zur Hand und darum die Verknüpfung in Codesys nachgestellt. Ist hier genauso.



Holger


----------



## COCO-RB (21 September 2017)

ich habe jetzt doch noch eine brauchbare Information vom Siemens Service erhalten.

Mit Wertzuweisung ist einfach nur gemeint, dass der Teil der auf der Linken Seite steht der Variablen auf der Rechten Seite zugeordnet wird.
Mit Gleichartigen Operanden sind dann die Verknüpfungen OR, AND usw. gemeint.
Ich kann den Code in SCL also in der gleichen Reihenfolge wie in AWL programmieren.
Es besteht jedoch der Unterschied, dass es bei SCL eine Rangordnung gibt und AND z.B. vor OR ausgeführt wird.
Um die Reihenfolge in meinem Fall sicherzustellen, müssen Klammen verwendet werden.

Die tatsächliche Reihenfolge spielt also keine Rolle, in jedem Fall gibt es eine Lösung.
Da mir das lesen von links nach rechts bzw. von oben nach unten (wie bei AWL) besser gefällt, habe ich die Zeilen noch einmal umgeschrieben.

Na das war jetzt aber ein Weg, hoffe mal einen Kurs besuchen zu dürfen!
Vielen Dank an alle für die guten Beiträge!


----------



## weißnix_ (21 September 2017)

Im ersten Ansatz habe ich vmtl. eine Klammer vergessen:



weißnix_ schrieb:


> ```
> #stat_Verz_StandBy.VAR_IN:=
> 
> ((#inout_Bereich_Ende or (
> ...



Ich werde das aber wohl heute abend mal im Twincat-Simulator durchspielen.


----------



## maxder2te (21 September 2017)

COCO-RB schrieb:


> // Auszug in AWL
> 
> U #inout_Bereich_Ende
> O(
> ...



Sorry, aber warum man solchen AWL-Code schreibt verstehe ich nicht. In FUP oder KOP lässt er sich nicht übersetzen.


Fpr die SCL-Variante:
Ich habe mir angewohnt die "Smart" Codeformatierung von S7 bzw. TIA-Portal abzuschalten und formatiere manuell, so das es hierarchisch lesbar wird. Der obige Code sieht dann halt so aus:


```
#stat_Verz_StandBy.VAR_IN := 
        (
[COLOR=#ff0000]            ([/COLOR]
                (
                    #stat_Regler.ProgPos.Statuswort."1_Bit_01_Einschaltbereit" 
                    AND (NOT #in_Referenzfahrt_starten) 
                    AND (NOT #in_Tippen_minus) 
                    AND (NOT #in_Tippen_plus)
                ) 
                AND #in_Halt_Vorschub 
            [COLOR=#ff0000])[/COLOR]
            OR [COLOR=#ff0000]([/COLOR]
                #in_Standby_erlauben 
                AND (
                    (
                        (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_00_M090_PLC_Kanal_0")
                        AND (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_01_M091_PLC_Kanal_1")
                        AND (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_02_M092_PLC_Kanal_2")
                        AND (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_03_M093_PLC_Kanal_3")
                        AND (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_04_M094_PLC_Kanal_4")
                        AND (NOT #stat_Regler.ProgPos.Steuerwort."2_Bit_05_M095_PLC_Kanal_5")
                    )
                    OR #inout_Bereich_Ende
                )
        [COLOR=#ff0000]    )[/COLOR]
        );
```

Die wesentlichen Merkmale sind das hierarchische Einrücken, das bedingungslose Klammern - so muss man nicht nachdenken ob OR oder AND stärker bindet. Zudem wird jedes NOT immer zum Operanden geklammert. Von der Logik her sieht es nun auch so ähnlich wie FUP aus.
Ach ja: die roten Klammern hab ich dazugefügt.

lg


----------



## Münchnerjunge (21 September 2017)

maxder2te schrieb:


> das bedingungslose Klammern - so muss man nicht nachdenken ob OR oder AND stärker bindet



Darf ich an dieser Stelle mal ne Randfrage stellen die nicht allzu viel mit dem eigentlichen Thema zu tun hat?

Falls ja:
Ist das nur so eine blöde Gewohnheit oder eine gängige Praxis unter uns Programmierern, dass man gerne mal ne Klammer zu viel/überflüssig setzt statt nachzudenken? Sollte man da nen schlechtes Gewissen haben, oder macht das den Code auch etwas einfacher bzw. lesbarer?


----------



## Chräshe (21 September 2017)

Lieber eine Klammer zu viel als eine zu wenig.
Wenn es der Lesbarkeit dient, kann eine Klammer nicht schaden.
Passend den Code einrücken hilft übrigens auch…


----------



## Onkel Dagobert (21 September 2017)

COCO-RB schrieb:


> .. Na das war jetzt aber ein Weg, hoffe mal einen Kurs besuchen zu dürfen!..


Du bist doch schon auf Kurs! Solche Sachen lernst du erst richtig in der Praxis, wozu man dieses Forum durchaus zählen darf.


----------



## COCO-RB (21 September 2017)

@weißnix_
Wertzuweisungen von rechts nach links- Da ist sowas gemeint:
 var_a:=var_b:=var_c:=var_d:=true;

Danke, das ist ein gutes Beispiel!

@maxder2te
Sorry, aber warum man solchen AWL-Code schreibt verstehe ich nicht. In FUP oder KOP lässt er sich nicht Übersetzen.

Der AWL-Code ist doch einfach zu lesen, oder nicht?
Eine automatische Umformatierung von AWL nach FUP ist für uns nicht wichtig, wir programmieren schon über 20 Jahre nur AWL.

Im Zuge der neuen S7-1500 CPU mit den neuen Möglichkeiten gegenüber der S7-300 werden wir die Programme komplett überarbeiten.
- 100% Symbolisch, keine Adressberechnungen bzw. Pointer, Strukturierung der Daten mit UDTs, möglichst keine globalen Daten sondern alles über die Bausteinschnittstelle (Multiinstanzfähig)
- Viele sehen in AWL keine Zukunft, Programmierer von der Uni denken eher in SCL, wir werden vermutlich Schrittweise zu SCL wechseln.
- Insbesondere bei längeren Bitverknüpfungen aufgrund der jetzigen Onlineanzeige bin ich aber noch unsicher. (es gibt ja kein VKE oder so)
- Vermutlich wird der Debugger von Siemens aber auch weiterentwickelt.

lg


----------



## rostiger Nagel (21 September 2017)

Bei deinen AWL Code muss man schon sehr genau hinschauen was du erreichen möchtest.
Wenn ich mir vorstellen, das man den ein paar Tage nicht gesehen hat und später bei einer
Fehlersuche unter Stress damit Arbeiten muss, würde ich versuchen das eleganter zu lösen. 
Jetzt wo ihr auf SCL umstellt, versucht ihr es genauso ungeschickt.
Da habe ich wenig Verständnis!


----------



## Thomas_v2.1 (21 September 2017)

Für solche Bitwürste ist SCL genauso geeignet oder ungeeignet wie AWL. 
Die Darstellungsart der Wahl wäre hier FUP/KOP oder CFC.

Für AWL existiert meiner Meinung nach kein Grund diese "Sprache" oder Darstellungsart zu wählen.


----------



## Blockmove (22 September 2017)

Ich sehe es genauso wie Thomas.
TIA kann jetzt SCL-Netzwerke.
Somit kann man wunderbar die alte Regel "Für jede Aufgabe das richtige Werkzeug" anwenden und solche Verknüpfungen in KOP oder FUP ausführen.

Gruß
Blockmove


----------



## COCO-RB (22 September 2017)

*Aufteilung SCL / FUP sinnvoll?*

Ich denke jede Lösung hat so seine Vor- und Nachteile.

Wenn in einem logischem Zusammenhang einer Anlage zwischendurch Bitverknüpfungen als FUP in einem gesondertem Netzwerk ausgelagert werden, kann leicht der Zusammenhang bzw. der Überblick verloren gehen. Zudem werden lange Variablen in FUP in mehreren Zeilen aufgeteilt. Allgemein benötigen FUP Netzwerke mehr Platz auf dem Bildschirm.

So eine Aufteilung eines FB in FUP und SCL werde ich aber Testweise mal umsetzen.

Wenn die Regeln der Bitverknüpfung in SCL einmal bekannt sind, sollte die grundsätzliche Programmierung genauso einfach wie in AWL umgesetzt werden können. In SCL hat der Programmierer zudem noch mehr Freiheiten in der Gliederung und Aufteilung. (Regionen, Einrücken usw...)

lg.
COCO


----------



## Onkel Dagobert (22 September 2017)

COCO-RB schrieb:


> .. Wenn die Regeln der Bitverknüpfung in SCL einmal bekannt sind ..


Das ist eigentlich genau so trivial wie die Grundrechenarten in der Mathematik. Unterstufe, so zu sagen  .


----------



## COCO-RB (22 September 2017)

:TOOL: 
In AWL spielt das halt keine Roll, deine Bemerkung ist sehr hilfreich!


----------



## Onkel Dagobert (22 September 2017)

COCO-RB schrieb:


> :TOOL:
> In AWL spielt das halt keine Roll, deine Bemerkung ist sehr hilfreich!



Nur wenn man sie versteht. Meine Bemerkung war trotz des Grinsens ernst gemeint. Und es ging um SCL, nicht um AWL, aber auch egal.


----------



## Larry Laffer (22 September 2017)

Blockmove schrieb:


> TIA kann jetzt SCL-Netzwerke.
> Somit kann man wunderbar die alte Regel "Für jede Aufgabe das richtige Werkzeug" anwenden und solche Verknüpfungen in KOP oder FUP ausführen.



Ich fände es anders herum schöner (gemäß deines Wahlspruchs) :
Nicht ein AWL- (oder ggf. SCL-) Netzwerk in KOP oder FUP einfügen ... sondern lieber ein KOP oder FUP-Newerk in SCL einfügen ...

Gruß
Larry


----------

