Typ als DW laden / awl

kiestumpe

kiestumpe

Level-1
Beiträge
726
Reaktionspunkte
84
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

Ich habe folgendes Problem:
Eine 32-er Schrittkette wird auf DW abgebildet. Zur besseren Lesbarkeit habe ich mir einen Datentyp mit 32 Boolschen Variablen angelegt, der die Schrittkette abbildet.
Jedoch sind auch Anweisung im Programm, die diesen Speicherbereich Doppelwordweise verarbeiten, z.B:

Code: 
  L     #SKX.DW_Step_OK_1           // DW_Schritte_OK   
 L      #SKX.DW_Step_Starten_1      // DW_Schritt_starten
  +D    
  L     #SKX.DW_Step_gestoert_1     // DW_Schritt_gestoert
  +D    
   L     0
    ==D

Solange ich alle Variablen im DW-Format lasse, raffts der L-Operator, sind sie als UDT angelegt, scheitert die Sache.
Gibts da sowas wie ein Casting, oder einen speziellen Ladebefehl ?
MfG

Frank
 
In dem Falle mußt du dann mit den direkten Lakalen Daten arbeiten, also
L LD 10 //LD 10 ist die Strucktur mit dem UDT. (Nummer findest du oben in der Schnittstellendefinition. Unschön ist, daß sich die Adressen verschieben können, wenn du neue Variablen einfügst.

Man kann auch am Anfang das LD 10 in ein LD umkopieren, das als "normales" Doppelwort definiert ist, um dann damit wieder über die symolischen Namen zu arbeiten. Allerdings muß man dann aufpassen, was man zum Schluß zurückkopiert und ob man dann geänderte Bit-Daten aus der UDT evtl. überschreibt. Will man nur Daten lesen geht es so ganz gut.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

vielen
Ralle schrieb:
In dem Falle mußt du dann mit den direkten Lakalen Daten arbeiten, also
L LD 10 //LD 10 ist die Strucktur mit dem UDT. (Nummer findest du oben in der Schnittstellendefinition. Unschön ist, daß sich die Adressen verschieben können, wenn du neue Variablen einfügst.
Zum Vergrößern anklicken....
vielen Dank für den Vorschlag,
jedoch was ich bezwecken möchte, nämich von den Adressen weg hin zur Symbolik, gelingt mir damit leider nicht.

D.h. entweder habe ich die Symbolische Adressierung für die einzelnen Bits und spreche die Doppelwörter per Adresse oder umgekehrt.
Ich dachte jedoch an solchen Konstrukt:
z.B.
Code: 
 L     #SKX.DW_Step_OK       // Als DW laden
...
U     #SKX.DW_Step_OK.Schritt01   //    Bit0 des DW's

kanns hier nur mal in C wiedergeben, wie's da aussehen könnte, falls das hilft

Akku1 = (DWORD) #SKX.DW_Step_OK

Gruss

kiestumpe
 
Das geht begrenzt in SCL mit dem Operator AT


Um mit einem weiteren Datentyp auf eine deklarierte Variable zuzugreifen, können Sie Sichten auf die Variable oder auf Bereiche innerhalb der Variablen definieren. Hierzu verwenden Sie das Schlüsselwort "AT". Eine Sicht ist nur lokal im Baustein sichtbar, sie wird nicht in die Schnittstelle übernommen. Eine Sicht darf wie jede andere Variable im Baustein verwendet werden. Sie erbt alle Eigenschaften der Variablen, auf die sie zeigt, nur der Datentyp ist neu.
Beispiel
Im folgenden Beispiel werden mehrere Sichten auf einen Eingangsparameter ermöglicht:
VAR_INPUT
Buffer : ARRAY[0..255] OF BYTE;
Telegram1 AT Buffer : UDT100 ;
Telegram2 AT Buffer : UDT200 ;
END_VAR
Der aufrufende Baustein versorgt den Parameter Buffer, die Namen Telegram1 und Telegram2 sieht er nicht. Dem aufgerufenen Baustein stehen nun 3 Möglichkeit zur Verfügung, die Daten zu interpretieren, nämlich als Feld unter dem Namen Buffer oder anders strukturiert unter Telegram1 oder Telegram2.
Regeln
  • <LI style="FONT-SIZE: 10pt">Die Deklaration einer weiteren Sicht auf eine Variable muss nach der Deklaration der Variablen, auf die sie zeigen soll, im selben Deklarationsblock erfolgen.
    <LI style="FONT-SIZE: 10pt">Eine Initialisierung ist nicht möglich.
  • Der Datentyp der Sicht muss mit dem Datentyp der Variablen kompatibel sein. Die Variable gibt die Größe der Speicherbereichs vor. Der Speicherbedarf der Sicht darf gleich oder kleiner sein. Darüber hinaus gelten folgende Kombinationsregeln:
Zum Vergrößern anklicken....

WIr hatten hier einen Thread dazu vor nicht allzu langer Zeit, finde ihn aber gerade nicht, glaube es ging auch um Any-Zeiger.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo kiestumpe,

du könntest unter AWL per Adressregister auf das Doppelwort symbolisch zugreifen.

Code: 
LAR2 P##SKX
L LD [AR2,P#0.0]

bzw.
Code: 
LAR2 P##SKX.DW_Step_OK_1
L LD [AR2,P#0.0]

oder so?
Code: 
LAR2 P##SKX
L LD [AR2,P#4.0]        !!


Gruß, Onkel
 
Zuletzt bearbeitet:
Das mit dem AT-Befehl scheint vollkommen sinnloser Käse zu sein.
Hab mal folgendes getestet:

Eine UDT erstellt:

Code: 
TYPE UDT95
  STRUCT
  //  Typbeschreibung
    STG_09 : BOOL ;    //Störung Aggregat
    STG_10 : BOOL ;    //Störung Aggregat
    STG_11 : BOOL ;    //Störung Aggregat
    STG_12 : BOOL ;    //Störung Aggregat
    STG_13 : BOOL ;    //Störung Aggregat
    STG_14 : BOOL ;    //Störung Aggregat
    STG_15 : BOOL ;    //Störung Aggregat
    STG_16 : BOOL ;    //Störung Aggregat
    STG_01 : BOOL ;    //Störung Aggregat
    STG_02 : BOOL ;    //Störung Aggregat
    STG_03 : BOOL ;    //Störung Aggregat
    STG_04 : BOOL ;    //Störung Aggregat
    STG_05 : BOOL ;    //Störung Aggregat
    STG_06 : BOOL ;    //Störung Aggregat
    STG_07 : BOOL ;    //Störung Aggregat
    STG_08 : BOOL ;    //Störung Aggregat
  END_STRUCT
END_TYPE

Dann in SCL folgende Deklaration:

Code: 
VAR_IN_OUT
  // In-OUT-Parameter  
  SPS_STM : Word ;     //Datenwort mit Störmeldungen für TP  
  SPS_STM_Bitfeld AT SPS_STM: UDT95;  
END_VAR

Das bemeckert dann der Compiler wie folgt:
"Der Typ der Sicht ist nicht mit dem Typ der Variablen verträglich."

Wenn ich also nur Sichten, auf gleiche Variablen oder identische Strukturen erzeugen kann, dann kann ich das auch gleich lassen.

Hat jemand sowas schon geschafft, ein Word als Input und das dann als Bitfeld verwenden? Aber bitte keine Umkopieraktionen in AWL, ich meine das Ganze mit dem AT-Befehl in SCL.
 
Mit folgender Deklaration meckert der Compiler zwar nicht mehr, dann muß ich aber auch ein Array am FC anlegen:

Code: 
VAR_IN_OUT
// In-OUT-Parameter 
SPS_STM : ARRAY[0..15] OF BOOL ; //Array of Bool mit Störmeldungen für TP 
SPS_STM_Bitfeld AT SPS_STM: UDT95; 
END_VAR
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Ralle,

welcher Datentyp der Variable mit dem Datentyp der Sicht vereinbar sind, ist in der SCL-Hilfe beschrieben. Elementare Datentypen wie Word kann man demnach als IN_OUT nur mit elementaren Datentypen sichten. Wenn du in deinem ersten Beispiel aus IN_OUT ein VAR_INPUT machst, und einen FB verwendest, geht es.
Was wann und wo geht, ist ganz schön verwirrend. Ich habe es jetzt auch nur in der Hilfe nachgelesen.


Gruß, Onkel
 
@Dagobert

Alles klar, hab's mal ausprobiert. Nützt mir aber wenig, da ich IN_OUT brauche und nicht soviele Instanz-DB haben will, schade.
 
Dank Dagoberts Hinweis hab jetzt eine Lösung mit umkopieren, die aber sehr übersichtlich ist:

Code: 
VAR_IN_OUT
  // In-OUT-Parameter  
  STM_Modul : WORD ;  //Datenword mit Störmeldung vom Modul 
  SPS_SM : WORD ;     //Datenwort mit Störmeldungen für TP  
  OP_Quitt : WORD ;   //Datenwort mit OP-Quittierung 
  SPS_Quitt : WORD ;  //Datenwort mit SPS-Quittierung 
END_VAR
VAR_TEMP
  // temporäre Variablen
 STM_Modul_Intern : WORD ;  
 STM_Modul_Bitfeld AT STM_Modul_Intern : UDT95; 
 SPS_SM_Intern : WORD ;     //Datenwort mit Störmeldungen für TP  
 SPS_SM_Bitfeld AT SPS_SM_Intern: UDT95;   
 OP_Quitt_Intern : WORD ;   //Datenwort mit OP-Quittierung 
 OP_Quitt_Bitfeld AT OP_Quitt_Intern: UDT95; 
 SPS_Quitt_Intern : WORD ;  //Datenwort mit SPS-Quittierung 
 SPS_Quitt_Bitfeld AT SPS_Quitt_Intern: UDT95;   
END_VAR
 
STM_Modul_Intern := STM_Modul;
SPS_SM_Intern := SPS_SM;
OP_Quitt_Intern := OP_Quitt;
SPS_Quitt_Intern := SPS_Quitt;
 
//STM 01 Modul
 
SYSTEM_STOERMELDUNG(Stoermeldung := STM_Modul_Bitfeld.STG_01 // IN: BOOL
                   ,Freigabe := Freigabe // IN: BOOL
                   ,Ack := Ack // IN: BOOL
                   ,Stoerbit :=  SPS_SM_Bitfeld.STG_01// INOUT: BOOL
                   ,Quittierbit_OP := OP_Quitt_Bitfeld.STG_01 // INOUT: BOOL
                   ,Quittierbit_SPS :=  SPS_Quitt_Bitfeld.STG_01// INOUT: BOOL
                   ); // VOID
 
 
  /// ... hier kommen noch 15 weitere Störmeldungen 
 
  STM_Modul := STM_Modul_Intern;
  SPS_SM := SPS_SM_Intern;
  OP_Quitt := OP_Quitt_Intern;
  SPS_Quitt := SPS_Quitt_Intern;

Muß ich allerdings noch testen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo!

Probier mal folgendes:
FC Deklaration:

TEMP: wort struct
Bit_0 als Bit
Bit_1 als Bit
....
Bit_15 als Bit
IN_OUT: IN_OUT_Eingang als WORD


FC 1.Netzwerk:

L P##wort //Wort ist IN_OUT
LAR1
L #IN_OUT_Eingang //Eingang = deklariert als Wort
T W [AR1,P#0.0] //Transeriere in Bit Struct (Struct mit 16
einzelnen Bits deklariert)

FC letztes Netzwerk:

L P##wort //Wort ist IN_OUT
LAR1

L W [AR1,P#0.0] //Transeriere in Bit Struct (Struct mit 16
einzelnen Bits deklariert)
T #IN_OUT_Eingang //Eingang = deklariert als Wort


MfG SPS Doofi
 
Es gibt noch eine Lösung:

Nimm einen FB

lege als STAT einen Struct wie oben an (einzelne Bits)

im FB kannst Du mittels SFC20 (Blockmove) das IN_OUT_Eingang Wort direkt in die Stat kopieren (symbolisch)

CALL "BLKMOV"
SRCBLK :=#IN_OUT_Eingang
RET_VAL:=#TEMP_ret_val
DSTBLK :=#STAT_Schritt_Bits


MfG SPS Doofi
 
@SPS_Doofi

Ja danke. Ähnliche Varianten hatten wir schon in diversen Ausführungen diskutiert, aber ich wollte in SCL gerne mal die Dinge nutzen (AT-Statement), die es anderen Programmierern später einfacher machen, den Code zu lesen. Mit "Zeigerakrobatik" kommen viele nicht so leicht klar, bzw. sich da reinzudenken kostet viel Zeit.

Die Methode mit dem Umkopieren nutze ich sonst auch in AWL.
 
Zurück
Oben