Hier wird Bytes-tauschen (TAW/TAD/SWAP) eher nicht gebraucht. Der TE will wissen, auf welche "Adresse" in der AT-View er Bits kopieren muß, damit sie im Word/Integer gleich an der gewünschten Bitposition zu liegen kommen.
Dazu muß man wissen, daß in einer S7 mehr-Byte-ige Datentypen im Big Endian gespeichert werden, also z.B. von einem Word zuerst das höherwertige Byte mit den Bits 8 bis 15 und dahinter das niederwertige Byte mit den Bits 0 bis 7.
Die Elemente eines Arrays liegen in "natürlicher" Reihenfolge im Speicher: zuerst kommt das erste Element mit dem ersten (üblicherweise niedrigsten) Index, und zuletzt kommt das letzte Element mit dem letzten (üblicherweise höchsten) Index. (Arrays liegen quasi im Little Endian im Speicher) Dadurch kann man (in Speicher mit Adressen) die Adresse eines Elementes leicht berechnen, z.B. bei Array[0..xx]:
Adresse des Elementes Array[n] = n * Datentypgröße_in_Byte + Anfangsadresse_des_Arrays
(Datentypen > 1 Byte haben immer eine Datentypgröße mit gerader Anzahl Bytes, ggf. wird ein Padding-Byte zugefügt)
Bei einem BOOL/Bit-Array errechnet sich die BitAdresse:
BitAdresse des Elementes BitArray[n] = n + Anfangsadresse_des_Arrays
Code:
+-----------------------+-----------------------+
|Byte_n |Byte_n+1 |
Adresse: |.0 .1 .2 .3 .4 .5 .6 .7|.0 .1 .2 .3 .4 .5 .6 .7|
+-----------------------+-----------------------+
Index: | 0| 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|13|14|15| <-- Index des Arrays[0..15] of BOOL
+-----------------------+-----------------------+
Bit: | 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7| <-- Bitnummer des Word
+-----------------------------------------------+
Anstatt mit einem BOOL-Array kann man das Word auch mit einem Struct aus BOOLs überlagern, das würde dann etwa so aussehen:
Code:
MyWord : Word;
MyBoolArray AT MyWord : ARRAY [0..15] OF BOOL;
MyWordStruct AT MyWord : STRUCT
Bit_8 : BOOL;
Bit_9 : BOOL;
Bit_10 : BOOL;
Bit_11 : BOOL;
Bit_12 : BOOL;
Bit_13 : BOOL;
Bit_14 : BOOL;
Bit_15 : BOOL;
Bit_0 : BOOL;
Bit_1 : BOOL;
Bit_2 : BOOL;
Bit_3 : BOOL;
Bit_4 : BOOL;
Bit_5 : BOOL;
Bit_6 : BOOL;
Bit_7 : BOOL;
END_STRUCT;
Soll ein Bit ins Bit 0 des Word kopiert werden, dann muß man es nach
MyWordStruct.Bit_0 kopieren oder nach
MyBoolArray[8] - ich finde die Struct-Variante verständlicher.
In TIA mit S7-1200/S7-1500 gibt es außer der AT-Überlagerung mit Array oder Struct noch eine weitere Möglichkeit für den Zugriff auf die Bits in einem Word - da kann man die Bits im Word direkt adressieren (sogenannter Slice-Zugriff), z.B. das Bit 0:
#MyWord.%X0
(es könnte aber sein, daß die AT-Überlagerung effizienter ist)
Harald
klaro also fängt er auch beim Arry von hinten an zu zaehlen..
