Position einer STAT-Variable feststellen

[Züttu]

Zuviel Werbung?
-> Hier kostenlos registrieren

Gibt es eine Möglichkeit die Position einer STAT-Variable im AR2 festzustellen? In einem FB habe ich 16 Statusbits die ich für mein Panel auf ein Wort kopiere, dabei mache ich denn dreher mit den MSB & LSB gleich rein, ich möchte aber nicht direkt auf mein AR2 zugreiffen da ich bei einer Änderung am Baustein sonst alles verschieben kann.

Im Moment sieht es so aus, und funktionert, ist nur leider nicht dynamisch:

      L     DIB [AR2,P#6.0]
      T     DIB [AR2,P#9.0]

      L     DIB [AR2,P#7.0]
      T     DIB [AR2,P#8.0]

Wobei auf Byte 6 & 7 meine Statusbytes lieben und auf Byte 8 & 9 mein Protokol-Wort

Ich hoffe ich hab mich einiegermassen verständlich ausgedrückt, bin für jede Hilfe dankbar.

 

[M-Ott]

Du kannst die Adresse der Variable über "L P##Variable" laden.

 

[Züttu]

Zuviel Werbung?
-> Hier kostenlos registrieren

Danke dir, werde das gleich versuchen und meine Erfahrungen posten.

 

[Züttu]

Soweit so gut, aber leider krieg ich es nicht hin Variablen in verschachtelten Struct zu suchen.

z.B L P##Status.HMI.protocol

Gibt es dafür auch eine Möglichkeit?

 

[M-Ott]

Habe ich auch noch nicht probiert.

Wenn es wirklich nur darum geht die Bytes zu tauschen, dann reicht es vielleicht schon aus, wenn Du ganz normal symbolisch auf Deine Variable zugreifst und dann ein "TAW" hinterschiebst.

 

[Züttu]

Zuviel Werbung?
-> Hier kostenlos registrieren

denn TAW Befehl kann ich in der Tat einsetzen, vielen Dank für deinen Tipp. Was die Funktionen betrifft funktionert mein Baustein auch, möchte nur verhindern das bei Änderungen im STAT-Register meine direkte Adressierung nicht mehr funktionert.....


Werde das ganze wahrscheinlich mit Kommentaren versehen und auf mein Erinnerungvermögen hoffen.

Danke trotzdem für deine Hilfe!!

 

[PN/DP]

Wie hast Du die Variable symbolisch deklariert? Ist das eine 32-Bit-Variable (DWord?)?
Dann kannst Du einfach symbolisch schreiben:

      L     #Status.HMI.protocol
      TAD   
      T     #Ausgabe_DW

Du kannst Deine Variablen auch symbolisch in die temporären Lokaldaten umkopieren und dabei die Lokaldaten absolut adressieren.
Da mußt Du Dir nur merken, daß die Kopier-Lokaldaten immer z.B. gleich am Anfang ab LB0 liegen müssen:

      L     #Status.HMI.Byte6
      T     LB     3
      L     #Status.HMI.Byte7
      T     LB     2
      L     #Status.HMI.Byte8
      T     LB     1
      L     #Status.HMI.Byte9
      T     LB     0
      L     #Temp_LD0
      T     #Ausgabe_DW

Harald

 

[Züttu]

Das Problem ist das ich 16 Bits habe die ich symbolisch deklariert habe und einen Protokol-Variable (word). Gelöst habe ich das nun folgendermassen:

      LAR1  P##command
      L     #command.hmi.protocol
      TAW   
      T     DIW [AR1,P#0.0]

 

[PN/DP]

Zuviel Werbung?
-> Hier kostenlos registrieren

Um Dir bessere Tips geben zu können, müßte man mal die genaue Deklaration Deiner Struktur sehen und wohin die gedrehten Bytes gespeichert werden sollen.

Die Operation TAW tauscht übrigens nur die 2 Bytes im Low-Word des Akku1. Du wolltest aber 4 aufeinanderfolgende Bytes komplett umdrehen - dafür ist TAD besser geeignet.

Harald

 

[Züttu]

Meine Deklaration sieht wie folgt aus:

STAT-Register

command.hmi.bit1 Bool
command.hmi.bit2 Bool
command.hmi.bit3 Bool
command.hmi.bit4 Bool
command.hmi.bit5 Bool
command.hmi.bit6 Bool
command.hmi.bit7 Bool
command.hmi.bit8 Bool
command.hmi.bit9 Bool
command.hmi.bit10 Bool
command.hmi.bit11 Bool
command.hmi.bit12 Bool
command.hmi.bit13 Bool
command.hmi.bit14 Bool
command.hmi.bit15 Bool
command.hmi.bit16 Bool
command.hmi.protocol Word

Ich möchte nur die ersten 16 command-bits auf mein protocol kopieren und dabei MSB und LSB tauschen.

 

[M-Ott]

Ich möchte nur die ersten 16 command-bits auf mein protocol kopieren und dabei MSB und LSB tauschen.

Laut Deinem Code genau andersrum (Du kopierst das Wort auf die einzelnen Bits).
Was spricht eigentlich dagegen, das ganze wortweise statt bitweise zu deklarieren?

 

[Züttu]

Zuviel Werbung?
-> Hier kostenlos registrieren

Mein Fehler, ich mach natürlich beides, status in die eine Richtung und command in die andere, sorry


ich möchte in meinem FB symbolisch auf die einzelnen bits zugreiffen, die Namen die ich in der Deklaration brauche sind natürlich nicht einfach durchnummeriert wie in meinem Beispiel, sondern tragen mehr oder weniger sinnvolle Namen.

 

[M-Ott]

Du könntest es wortweise deklarieren, legst es zu Beginn des Bausteins auf Bitweise deklarierte TEMP-Variable und transferierst es am Ende wieder zurück, und damit Du das wortweise machen kannst, holst Du Dir mit "LAR1 P##Erstes_TEMP_Bit" die Adresse von Deinem ersten Bit. Dann musst Du nur darauf achten, dass 16 Bit bei L XX.0 beginnen

 

[PN/DP]

Ah, jetzt wird klar, was Du willst (ein paar Deiner Aussagen waren widersprüchlich ).

Hier ein FC, mit dem Du MSB und LSB in einem Word tauschen kannst und die Parameter symbolisch dranschreiben kannst.
IN_Adr und OUT_Adr kann auch der Beginn eines Bitfeldes sein, hauptsache, an den angegeben Adressen ist Platz für ein Word.
Der FC ermittelt die Adresse der übergebenen Parameter (kann Merker-, DB- und STAT-Bereich sein) und kopiert dann ein Word,
wobei MSB und LSB vertauscht werden.
Die IN-/OUT-Adressen müssen an Byte-Grenzen liegen bzw. das wird erzwungen.

FUNCTION "iTBW" : VOID
TITLE =Reihenfolge der Bytes in einem Word tauschen, indirekt
AUTHOR : PN_DP
VERSION : 0.1

VAR_INPUT
  IN_Adr : POINTER ;	//Pointer auf zu lesendes Word
  OUT_Adr : POINTER ;	//Pointer auf zu schreibendes Word
END_VAR
VAR_TEMP
  Ptr_DB : WORD ;	
  Ptr_Ofs : DWORD ;	
  Value : WORD ;	
END_VAR

BEGIN
NETWORK
TITLE =

//Pointer auf IN-Word in AR1 erstellen
      L     P##IN_Adr; 
      LAR1  ; 
      L     W [AR1,P#0.0]; 
      T     #Ptr_DB; 
      L     D [AR1,P#2.0]; 
      UD    DW#16#FFFFFFF8;  //auf P#x.0 zwingen
      T     #Ptr_Ofs; 

      AUF   DB [#Ptr_DB]; 
      LAR1  #Ptr_Ofs; 

//IN-Word lesen
      L     W [AR1,P#0.0]; 
      T     #Value; 

//Pointer auf OUT-Word in AR1 erstellen
      L     P##OUT_Adr; 
      LAR1  ; 
      L     W [AR1,P#0.0]; 
      T     #Ptr_DB; 
      L     D [AR1,P#2.0]; 
      UD    DW#16#FFFFFFF8;  //auf P#x.0 zwingen
      T     #Ptr_Ofs; 

      AUF   DB [#Ptr_DB]; 
      LAR1  #Ptr_Ofs; 

//IN-Word MSB-LSB-gedreht auf OUT-Word ausgeben
      L     #Value; 
      TAW   ;                //MSB-LSB tauschen
      T     W [AR1,P#0.0]; 

END_FUNCTION

Aufrufen kannst Du den FC z.B. so:

      CALL  "iTBW"
       IN_Adr :=#command.hmi.bit1
       OUT_Adr:=#command.hmi.protocol

Harald