TIA TIA v14+SP1+UPD5 / 1512C / SCL / Peripherieeingänge in temp sichern

[asm]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

Ich könnte nachfolgendes locker in AWL umsetzen, wollt mich aber mal in SCL versuchen.

Ziel: die Engänge eines Leuze CML720i (Messlichtgitter oder kurz "MLG") in den TEMP-Breich eines FB's sichern.

​

Mit diesem MLG kann ich 32 Strahlen abfragen. Jeder Strahl entspricht ein Bit.

In der 300er Steuerung habe ich die Peripherieeingänge ganz einfach ausgelesen:

      L     #Baugruppenadresse
      SLW   3
      LAR1  
      LAR2  P##t_strahlen
      L     PED [AR1,P#0.0]             // Byte-Betrachtung des Doppelwortes: A B C D
      TAD                               // Byte-Betrachtung des Doppelwortes: D C B A
      RLD   16                          // Byte-Betrachtung des Doppelwortes: B A D C
      T     LD [AR2,P#0.0]              // High / Low-Bytes müssen Wortweise gedreht werden

In der 1500er Steuerung mit SCL schaut das alles komplett anders aus.

Netzwerk 1: Startadresse sowie Länge des Eingangsbereiches speichern:

    [COLOR=#008000]// Basisadressen auslesen[/COLOR]
    #geoAddr.HWTYPE := 4;                       // Hardwaretyp: 4 = Modul
    #geoAddr.IOSYSTEM := #idMastersystem;       // ID des Mastersystems (1..99 = PROFIBUS DP, 100.. = PROFINET IO)
    #geoAddr.STATION := #pndpTeilnehmer;        // Stationsnummer
    #geoAddr.SLOT := 1;                         // Steckplatz-Nummer
    #RetVal := GEO2LOG(GEOADDR := #geoAddr, LADDR => #rd_Addr.lAddr);
    [COLOR=#008000]// Startadresse und Anzahl der Eingangsbytes auslesen (Ausgänge gibt es nicht)[/COLOR]
    #RetVal := RD_ADDR(LADDR := #rd_Addr.lAddr, [COLOR=#ff0000]PIADDR => #rd_Addr.PIAddr[/COLOR], [COLOR=#0000ff]PICount => #rd_Addr.PICount[/COLOR],PQADDR => #rd_Addr.PQAddr, PQCount => #rd_Addr.PQCount);

Jetzt komme ich zu meinem Problem: Ich möchte WORD-weise die Eingänge in den TEMP-Bereich sichern. Hier mein Ansatz:

FOR #i := 1 TO SHR(IN := UINT_TO_INT(#rd_Addr.PICount), N := 1) BY 1 DO
    #ew[#i] := SWAP([B][COLOR=#ff0000]%EW[/COLOR][/B](UDINT_TO_DINT(#rd_Addr.PIAddr) + #n):P);
    #n := #n + 2;    [COLOR=#008000]// nächstes Eingangswort[/COLOR]
END_FOR;

Im Kopf betrachtet bedeutet das:
--> #rd_Addr.PICount = 4 (siehe angehängtes Bild .. es sind 4 Byte)
--> SHR1 von #rd_Addr.PICount (schiebe das wort um 1 nach rechts was soviel bedeutet wie: #rd_Addr.PICount / 2 = 2 Worte)
--> #rd_Addr.PICount = 2
--> FOR i=1 TO 2 DO:

tempword = gedrehtes Eingangswort​

Dummerweise ist das %EW rot untermalt. Das heißt, TIA kann damit nix anfangen. Habt Ihr eine Idee, wie ich das elegant lösen kann ?

 

[jat]

Per Slice Zugriff wäre das doch einfacher zu lösen.

 

[asm]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo jat,

ich habe von SCL leider nur wenig Plan. Das muss ich mir erst Stück für Stück erarbeiten. Ich bin mir auch gar nicht sicher, ob mein Vorhaben sich mit SCL realisieren lässt. Deswegen - keine Ahnung was Du damit "per slice" meinst. ^^

Mein Kopf hängt noch viel zu sehr an der 300er Steuerung und dem guten alten AWL..

[COLOR=#008000]// Adressregister 2 sichern[/COLOR]
      TAR2  #Registersicherung.Adressregister_2

[COLOR=#008000]// Pointer belegen[/COLOR]
      L     #rd_Addr.PIAddr      [COLOR=#008000]// Startadresse[/COLOR]
      SLD   3                    [COLOR=#008000]// = Byte.Bit[/COLOR]
      LAR1
      LAR2  P##t_beams

[COLOR=#008000]// Anzahl gefundener Eingangsworte ist Schleife[/COLOR]
      L     #rd_Addr.PICount     [COLOR=#008000]// Anzahl Eingangsbytes[/COLOR]
      SRW   1                    [COLOR=#008000]// = Anzahl Eingangsworte[/COLOR]
      T     #eingangsworte
s1:   T     #sz
[COLOR=#008000]//  Schleifenzaehler umkehren und als Adressoffset speichern[/COLOR]
      L     #eingangsworte
      L     #sz
      -I
      T     #offset
      SLW   4                    [COLOR=#008000]// Offset auf das nächste Wort[/COLOR]
      +AR1
      +AR2
[COLOR=#008000]// Eingangswort drehen und lokal sichern[/COLOR]
      L PEW [ AR1 , P#0.0 ]      [COLOR=#008000]// Byte-Betrachtung des Wortes: A B[/COLOR]
      TAW                        [COLOR=#008000]// Byte-Betrachtung des Wortes: B A[/COLOR]
      T LW [ AR2 , P#0.0 ]       [COLOR=#008000]// speichere gedrehtes Eingangswort lokal in Bool-Array ab[/COLOR]
      L     #sz
      LOOP  s1

[COLOR=#008000]//  AR2 wiederherstellen[/COLOR]
      LAR2  #Registersicherung.Adressregister_2

So schaut mein Vorhaben in AWL aus.

 

[RogerSchw85]

Der Slice Zugriff gibt es nicht nur in SCL sondern in jeder Sprache bei den neuen Steuerungen.

In der TIA Hilfe findest du Informationen dazu.

Der Slice Zugriff wird benötigt um Symbolisch auf die Bit von einem Byte zuzugreifen. Oder auf die Byte von einem Word, usw...

#byte_0 := #wort.%B0;

Finde ich persönlich 1000 mal angenehmer und sauberer als dieses Konstrukt aus AWL...

 

[jat]

Ich bin mir auch gar nicht sicher, ob mein Vorhaben sich mit SCL realisieren lässt.

Das lässt sich auf jeden Fall mit SCL realisieren.

Mein Kopf hängt noch viel zu sehr an der 300er Steuerung und dem guten alten AWL..

Bin überhaupt kein Fan von AWL, weg damit :sw3:

Der Slice Zugriff gibt es nicht nur in SCL sondern in jeder Sprache bei den neuen Steuerungen.

Das stimmt sobald eine der neuen "TIA" Steuerungen verwendet wird, ist der Slice Zugriff verfügbar.

 

[asm]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ich versperre mich neuen Dingen nicht.

Allerdings löst der Slice mein Problem nicht. Ich kann per SCL schlicht keine PEW(#Adresse) auslesen.

Das hier schluckt er nicht:

#temp_word := SWAP([U][COLOR=#ff0000]%EW[/COLOR][/U](#rd_Addr.PIAddr):P);

Ich brauch quasi dieses AWL Konstrukt in SCL:

[COLOR=#008000]// Eingangswort drehen und lokal sichern[/COLOR]
      L PEW [ AR1 , P#0.0 ]      [COLOR=#008000]// Byte-Betrachtung des Wortes: A B[/COLOR]
      TAW                        [COLOR=#008000]// Byte-Betrachtung des Wortes: B A[/COLOR]
      T LW [ AR2 , P#0.0 ]       [COLOR=#008000]// speichere gedrehtes Eingangswort lokal in Bool-Array ab[/COLOR]

 

[asm]

Bin überhaupt kein Fan von AWL, weg damit :sw3:

Ich bin damit aufgewachsen. AWL lesen und verstehen zu können ist sicher auch bei den neuen 1500er Steuerungen kein Nachteil.

 

[RogerSchw85]

Warum willst du den Grundsätzlich direkt auf die Peripherie zugreifen?

Du könntest ja auch ganz einfach auf das Eingangswort...

 

[asm]

Zuviel Werbung?
-> Hier kostenlos registrieren

Weil ich meinen Kollegen die Arbeit ersparen will, freie Eingänge im PA zu suchen. Der FB soll die Eingänge nehmen, die in der Gerätekonfiguration im Subslot 1 drin stehen - egal ob Anfangsadresse 0 oder 1000

Es können auch mehr als nur 4 Eingangsbytes sein. Je länger das MLG ist, desto mehr Strahlen hat es und umso mehr Eingänge müssen projektiert werden.

Und ich will nicht jedesmal den FB umschreiben müssen, nur weil anstelle von 4 Byte irgendwann mal 8 Byte projektiert sind.

Abgesehn davon:

#temp_word := SWAP([COLOR=#ff0000]%EW[/COLOR](#rd_Addr.PIAddr):P);
#temp_word := SWAP([COLOR=#ff0000]%EW[/COLOR](#rd_Addr.PIAddr));

.. ob ich nun versuche EW oder PEW zu lesen .. es funktioniert beides nicht.

 

[RogerSchw85]

Das geht so auch nicht.

Da das TIA nur noch symbolisch arbeitet gibt kannst du so nicht direkt auf eine Adresse zugreifen. Sondern müsstest in den PLC-Variablen diese definieren, dann funktioniert der Zugriff:

#temp_word := SWAP("ew1000");

Du könntest das ganze vielleicht mit Arrays lösen. Aber ich verstehe dein Problem tatsächlich nicht ganz tut mir leid...

Hmm du könntest es mit Datentypen machen. Einen Grunddatentyp und in dem Datentyp einer für 4 Bytes und einer für 16Bytes. Danach kannst du diese in einem FB gemütlich per Slice drehen.

 

[TP-Inc]

Warum verwendest du nicht einfach einen PLC-Datentypen der deine 32 Strahlen enthält und plazierst ihn in der Symboltabelle an der richtigen Adresse ? Bei der1500er sind immer alle Ein/Ausgänge im PA...

Alles ist symbolisch, jeder findet Querverweise, alle sind Happy