Auf einzelne Bits einer IN_Variable (Typ Word) zugreifen?

[thorsten]

Hallo,

Habe hier eine Funktion in der ich als "In-Variable" ein Statuswort einlese,
wie kann ich jetzt innerhalb der Funktion direkt auf die einzelnen Bits zugreifen?
Also in etwa so:
( U #IN_Var.BX0.4
S DB_Fehler.dbx0.4)
( 4. Bit des Statuswort bedeutet Fehler xjz )

Rangieren auf ein Merkerwort will ich nicht, da der Baustein in mehreren Programmen verwendbar sein soll und ich da nicht Platz in der Symbolik reservieren will.

Vielen Dank schonmal,

mfg Thorsten

[Ralle]

Erstelle dir eine Temp-Variable mit den Bits zum Zugreifen.

Am Bausteinanfang Umrangieren der IN-Var in die Temp-Var

L #IN_VAR_1
T LW 2             //in der Temp-Deklarations-Tabelle steht die Adresse (hier z.Bsp. LW 2)

[thorsten]

Hallo,

Ja so weit ist mir das schon klar, aber wie greife ich jetzt auf die einzelnen Bits zu?



Also ich habe ne Invariable vom Typ WORD: #IN_VAR_1
Eine Temp Variable Typ WORD: LW_2


Jetzt möchte ich im Baustein prüfen ob zb. das 4. Bit der übergebenen Variablen 1 ist, wie mache ich das?

mfg thorsten

[Anonymous]

1.Kliken auf Variable (rechte Taste) ...Eingenschaften
2. Welche Lokaldaten sind zugeordnet ? z.B. 0.0
3. Dann Bit 0 ....U L1.0
Bit 1....U L1.1 usw.

[Onkel Dagobert]

Hallo Thorsten,

wie Ralle schon geschrieben hat, kannst du auch Bit-Variablen des entsprechenden LW anlegen und auf diese symbolisch zugreifen. Du musst nur darauf achten dass sie bei Bausteinänderungen unverändert im Adressbereich bleiben. Am besten ganz nach oben legen (ab Adresse 0.0).

Gruss, Onkel

[Ralle]

noch etwas ausführlicher zu Onkels Ergänzung:

Torsten schrieb:

Eine Temp Variable Typ WORD: LW_2

Nein, du legst Bitvariablen an, am besten für das gesamte Wort:

Bit_Var_0 BOOL 2.0
Bit_Var_1 BOOL 2.1
.
.
.
Bit_Var_15 BOOL 3.7

wenn du jetzt umrangiertst, kannst du symbolisch auf #Bit_Var_1 zugreifen.

Die Adresse ergibt sich aus der Stellung deiner Temp-Variable und erscheint in der 3.Spalte unter Adresse.

Teddys Variante geht genauso, aber dann hast du keinen symbolischen Zugriff, was die Lesbarkeit bei großen Bausteinen verschlechtert.

Gleiches geht auch mit INOUT-Var, dann mußt du am Ende des Bausteins wieder zurückrangieren.

[Rayk]

Hallo,
eine weitere Möglichkeit um einzelne Bits auf 1-Signal zu prüfen ist das Maskieren mit dem UW-Befehl.
Auf das zu prüfende WORT wird eine Maske gelegt in welcher das Bit, welches auf 1 -Signal geprüft werden soll, 1-Signal hat.
Danach wird der Befehl UND-Wort (UW) ausgeführt.
Da eben 1 UND 1 = 1 ist, steht im AKKU nach dem UW-Befehl eine 0, wenn das geprüfte Bit nicht 1 ist und eine Zahl >0, wenn das Bit 1-Signal hat.
Wenn das Ergebnis des UW-Befehls (Akku Inhalt) mit 0 verglichen wird, kann man den Zieloperand vom Vergleichsergebnis her beeinflussen.

Hier ist ein Beispiel, welches auch in FUP dargestellt werden kann:

NETWORK
TITLE =Prüfen
L #IN_Var; //Input-Variable
L W#16#8; // Maske 00000000 00001000
UW ; // Bit 4 auf 1 Prüfen
T #ZE_1; // Ergebnis speichern
NOP 0;
NETWORK
TITLE =Auswertung
//Operand "Bit_4_TRUE" hat 1-Signal,wenn wenn Bit 4 "TRUE"-Signal hat
L #ZE_1;
L 0;
>I ;
= #BIT_4_TRUE;

Gruss, Rayk

[Anonymous]

Oder man definiert eine struktur variable z.b.

VAR_INPUT
  DEINE_VARIABLE : INT ; 
END_VAR

VAR_OUTPUT
  OK: BOOL ;  //ein ergebnis
END_VAR
.
.
VAR_TEMP
  tsw : STRUCT  //bit struktur
   B00 : BOOL ;
   DBX01 : BOOL ;
   B02 : BOOL ; 
   B03 : BOOL ; 
   B04 : BOOL ; 
   B05 : BOOL ; 
   DBX06 : BOOL ; 
   B07 : BOOL ; 
   B10 : BOOL ; 
   B11 : BOOL ; 
   B12 : BOOL ; 
   B13 : BOOL ; 
   B14 : BOOL ;
   B15 : BOOL ; 
   B16 : BOOL ; 
   B17 : BOOL ; 
  END_STRUCT ;  
END_VAR

NETWORK
TITLE =daten in die struktur variable schaufeln
// tsw darf nicht geändert werden sonst muss
// T     LW     0 angepasst werden
      L     #DEINE_VARIABLE
      T     LW     0; //absolute adressierung in L-Bereich

NETWORK
TITLE =fu bereit
      U     #tsw.DBX01; 
      U     #tsw.B16; 
      U     #tsw.B04; 
      =     #OK;

da die struktur in der schnittstellendefinition mit drin ist kannst du den
baustein ohne zusätzlich UDTs verwenden.

[Anonymous]

es fehlt noch ein TAW !

.
.
 L  #DEIN_VARIABLE
 TAW
 T  LW 2
.
.

[Peter Wahlen]

Hallo Thorsten,

dieses Lösungen mögen funktionieren, aber sie haben einen Nachteil, weil sie mit absoluten Adressen der Lokaldaten arbeiten. (Beim Einfügen von neuen Temp-VAriablen können sich die Adressen verschieben.)

Wenn Du die Adresse der Lokaldaten auf einen Pointer legt und dann mit dem Pointer arbeitest, bist Du von evtuellen Erweitungen der Lokaldatentabelle unabhängig.

Beispiel:

L #Eingangswert (Byte, Wort, ...)
T #Hilfsvariable

LAR1 P##Hilfsvariable // Pointerwert und Bereichskennung laden (Adresse von Lokaldatenbyte/wort "Hilfsvariable")
U L [AR1,P#0.0] // Abfrage Bit 0
= .....
U L [AR1,P#0.1] // Abfrage Bit 1
= ....


Du kannst auch das AR2 mit benutzen, wenn Du von 2 verschiedenen Eingangswörten Bitergebnisse benötigst.

vill Jröß (viele Grüße)
Peter